zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'develop' of develop.openfoam.com:Development/OpenFOAM-plus into develop

Browse Source
This commit is contained in:
sergio
2018-08-09 15:10:45 -07:00
parent 0be3caec4a c1223095c4
commit a8e3f06762
28 changed files with 438 additions and 964 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
applications/test/hexRef8/block/system/decomposeParDict
View File

@ -17,22 +17,6 @@ FoamFile
numberOfSubdomains 2;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -126,6 +110,38 @@ structuredCoeffs
method scotch;
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches,
patches (cyclic_half0 cyclic_half1);
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
processors
{
type singleProcessorFaceSets;
sets ((f0 -1));
}
}
*/
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

52
applications/test/mapDistributePolyMesh/cavity/system/decomposeParDict
View File

@ -17,27 +17,6 @@ FoamFile
numberOfSubdomains 2;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Keep owner and neighbour of baffles on same processor (i.e. keep it
// detectable as a baffle). Baffles are two boundary face sharing the
// same points.
//preserveBaffles true;
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -130,6 +109,37 @@ structuredCoeffs
method scotch;
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches,
patches (cyclic_half0 cyclic_half1);
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
processors
{
type singleProcessorFaceSets;
sets ((f0 -1));
}
}
*/
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

52
applications/test/mapDistributePolyMesh/cavity/system/decomposeParDict-2
View File

@ -17,27 +17,6 @@ FoamFile
numberOfSubdomains 2;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Keep owner and neighbour of baffles on same processor (i.e. keep it
// detectable as a baffle). Baffles are two boundary face sharing the
// same points.
//preserveBaffles true;
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -130,6 +109,37 @@ structuredCoeffs
method scotch;
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches,
patches (cyclic_half0 cyclic_half1);
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
processors
{
type singleProcessorFaceSets;
sets ((f0 -1));
}
}
*/
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

52
applications/test/mapDistributePolyMesh/cavity/system/decomposeParDict-5
View File

@ -17,27 +17,6 @@ FoamFile
numberOfSubdomains 5;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Keep owner and neighbour of baffles on same processor (i.e. keep it
// detectable as a baffle). Baffles are two boundary face sharing the
// same points.
//preserveBaffles true;
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -130,6 +109,37 @@ structuredCoeffs
method scotch;
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches,
patches (cyclic_half0 cyclic_half1);
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
processors
{
type singleProcessorFaceSets;
sets ((f0 -1));
}
}
*/
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

46
applications/test/patchRegion/cavity_pinched/system/decomposeParDict
View File

@ -17,22 +17,6 @@ FoamFile
numberOfSubdomains 2;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -125,6 +109,36 @@ structuredCoeffs
method scotch;
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches,
patches (cyclic_half0 cyclic_half1);
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
processors
{
type singleProcessorFaceSets;
sets ((f0 -1));
}
}
*/
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

1
src/OpenFOAM/containers/Lists/FixedList/FixedList.H
View File

@ -467,7 +467,6 @@ inline void Swap(FixedList<T,Size>& lhs, FixedList<T,Size>& rhs);
//- Hashing for FixedList data, which uses Hasher for contiguous data and
//- element-wise incrementally hashing otherwise.
template<>
template<class T, unsigned N>
struct Hash<FixedList<T, N>>
{

1
src/OpenFOAM/containers/Lists/List/List.H
View File

@ -348,7 +348,6 @@ public:
//- Hashing for List data, which uses Hasher for contiguous data and
//- element-wise incrementally hashing otherwise.
template<>
template<class T>
struct Hash<List<T>>
{

1
src/OpenFOAM/containers/Lists/UList/UList.H
View File

@ -594,7 +594,6 @@ inline void Swap(UList<T>& a, UList<T>& b);
//- Hashing for UList data, which uses Hasher for contiguous data and
//- element-wise incrementally hashing otherwise.
template<>
template<class T>
struct Hash<UList<T>>
{

1
src/OpenFOAM/primitives/Pair/Pair.H
View File

@ -158,7 +158,6 @@ public:
//- Hashing for Pair data, which uses Hasher for contiguous data and
//- element-wise incrementally hashing otherwise.
template<>
template<class T>
struct Hash<Pair<T>>
{

404
src/overset/dynamicOversetFvMesh/dynamicOversetFvMesh.C.orig
View File

@ -1,404 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014-2017 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify i
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "dynamicOversetFvMesh.H"
#include "addToRunTimeSelectionTable.H"
#include "cellCellStencilObject.H"
#include "zeroGradientFvPatchFields.H"
#include "lduPrimitiveProcessorInterface.H"
#include "globalIndex.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(dynamicOversetFvMesh, 0);
addToRunTimeSelectionTable(dynamicFvMesh, dynamicOversetFvMesh, IOobject);
}
// * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * * //
bool Foam::dynamicOversetFvMesh::updateAddressing() const
{
const cellCellStencilObject& overlap = Stencil::New(*this);
// The (processor-local part of the) stencil determines the local
// faces to add to the matrix. tbd: parallel
const labelListList& stencil = overlap.cellStencil();
// Get the base addressing
const lduAddressing& baseAddr = dynamicMotionSolverFvMesh::lduAddr();
// Add to the base addressing
labelList lowerAddr;
labelList upperAddr;
label nExtraFaces;
const globalIndex globalNumbering(baseAddr.size());
labelListList localFaceCells;
labelListList remoteFaceCells;
labelList globalCellIDs(overlap.cellInterpolationMap().constructSize());
forAll(baseAddr, cellI)
{
globalCellIDs[cellI] = globalNumbering.toGlobal(cellI);
}
overlap.cellInterpolationMap().distribute(globalCellIDs);
reverseFaceMap_ = fvMeshPrimitiveLduAddressing::addAddressing
(
baseAddr,
stencil,
nExtraFaces,
lowerAddr,
upperAddr,
stencilFaces_,
globalNumbering,
globalCellIDs,
localFaceCells,
remoteFaceCells
);
if (debug)
{
Pout<< "dynamicOversetFvMesh::update() : extended addressing from"
<< " nFaces:" << baseAddr.lowerAddr().size()
<< " to nFaces:" << lowerAddr.size()
<< " nExtraFaces:" << nExtraFaces << endl;
}
// Extract relevant remote processors
labelList nbrProcs(localFaceCells.size());
{
label nbrI = 0;
forAll(localFaceCells, procI)
{
if (localFaceCells[procI].size())
{
//Pout<< " from proc:" << procI
// << " want its local cells " << remoteFaceCells[procI]
// << " to add to my local cells:" << localFaceCells[procI]
// << endl;
nbrProcs[nbrI++] = procI;
}
}
nbrProcs.setSize(nbrI);
}
// Construct interfaces
remoteStencilInterfaces_.setSize(nbrProcs.size());
forAll(nbrProcs, i)
{
label procI = nbrProcs[i];
remoteStencilInterfaces_.set
(
i,
new lduPrimitiveProcessorInterface
(
localFaceCells[procI],
Pstream::myProcNo(),
procI,
tensorField(0),
Pstream::msgType()
)
);
}
// Get addressing and interfaces of all interfaces
List<const labelUList*> patchAddr;
{
const fvBoundaryMesh& fvp = boundary();
patchAddr.setSize(fvp.size() + remoteStencilInterfaces_.size());
allInterfaces_ = dynamicMotionSolverFvMesh::interfaces();
allInterfaces_.setSize(patchAddr.size());
forAll(fvp, patchI)
{
patchAddr[patchI] = &fvp[patchI].faceCells();
}
forAll(remoteStencilInterfaces_, i)
{
label patchI = fvp.size()+i;
const lduPrimitiveProcessorInterface& pp =
remoteStencilInterfaces_[i];
//Pout<< "at patch:" << patchI
// << " have procPatch:" << pp.type()
// << " from:" << pp.myProcNo()
// << " to:" << pp.neighbProcNo()
// << " with fc:" << pp.faceCells().size() << endl;
patchAddr[patchI] = &pp.faceCells();
allInterfaces_.set(patchI, &pp);
}
}
const lduSchedule ps
(
lduPrimitiveMesh::nonBlockingSchedule<processorLduInterface>
(
allInterfaces_
)
);
lduPtr_.reset
(
new fvMeshPrimitiveLduAddressing
(
nCells(),
std::move(lowerAddr),
std::move(upperAddr),
patchAddr,
ps
)
);
// Check
if (debug)
{
const lduAddressing& addr = lduPtr_(); //this->lduAddr();
Pout<< "Adapted addressing:"
<< " lower:" << addr.lowerAddr().size()
<< " upper:" << addr.upperAddr().size() << endl;
lduInterfacePtrsList iFaces = this->interfaces();
// Using lduAddressing::patch
forAll(patchAddr, patchI)
{
Pout<< " " << patchI << "\tpatchAddr:"
<< addr.patchAddr(patchI).size()
<< endl;
}
// Using interfaces
Pout<< "iFaces:" << iFaces.size() << endl;
forAll(iFaces, patchI)
{
if (iFaces.set(patchI))
{
Pout<< " " << patchI << "\tiFace:" << iFaces[patchI].type()
<< endl;
}
}
Pout<< "end of printing." << endl;
}
return true;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::dynamicOversetFvMesh::dynamicOversetFvMesh(const IOobject& io)
:
dynamicMotionSolverFvMesh(io),
active_(false)
{
// Load stencil (but do not update)
(void)Stencil::New(*this, false);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::dynamicOversetFvMesh::~dynamicOversetFvMesh()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const Foam::lduAddressing& Foam::dynamicOversetFvMesh::lduAddr() const
{
if (!active_)
{
return dynamicMotionSolverFvMesh::lduAddr();
}
if (lduPtr_.empty())
{
// Build extended addressing
updateAddressing();
}
return *lduPtr_;
}
const Foam::fvMeshPrimitiveLduAddressing&
Foam::dynamicOversetFvMesh::primitiveLduAddr() const
{
if (lduPtr_.empty())
{
FatalErrorInFunction
<< "Extended addressing not allocated" << abort(FatalError);
}
return *lduPtr_;
}
bool Foam::dynamicOversetFvMesh::update()
{
if (dynamicMotionSolverFvMesh::update())
{
// Calculate the local extra faces for the interpolation. Note: could
// let demand-driven lduAddr() trigger it but just to make sure.
updateAddressing();
// This should be done when there is actually a changed in
// the new addressing. This sshould no update old fields.
interpolateFields();
return true;
}
return false;
}
bool Foam::dynamicOversetFvMesh::interpolateFields()
{
{
auto flds(this->lookupClass<volScalarField>());
for (auto fldPtr : flds)
{
auto& fld = *fldPtr;
if
(
fld.name() != "cellMask"
&& fld.name() != "cellMask_0"
&& fld.name() != "interpolatedCells"
&& fld.name() != "k_0"
&& fld.name() != "epsilon_0"
&& fld.name() != "alpha.water_0"
&& fld.name() != "rho_0"
)
{
Pout << "Interpolating : " << fld.name() << endl;
interpolate(fld.primitiveFieldRef());
}
}
}
{
auto flds(this->lookupClass<volVectorField>());
for (auto fldPtr : flds)
{
auto& fld = *fldPtr;
if
(
fld.name() != "cellDisplacement"
&& fld.name() != "U_0"
)
{
Pout << "Interpolating : " << fld.name() << endl;
interpolate(fld.primitiveFieldRef());
}
}
}
return true;
}
bool Foam::dynamicOversetFvMesh::writeObject
(
IOstream::streamFormat fmt,
IOstream::versionNumber ver,
IOstream::compressionType cmp,
const bool valid
) const
{
bool ok = dynamicMotionSolverFvMesh::writeObject(fmt, ver, cmp, valid);
// For postprocessing : write cellTypes and zoneID
{
const cellCellStencilObject& overlap = Stencil::New(*this);
const labelUList& cellTypes = overlap.cellTypes();
volScalarField volTypes
(
IOobject
(
"cellTypes",
this->time().timeName(),
*this,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
*this,
dimensionedScalar(dimless, Zero),
zeroGradientFvPatchScalarField::typeName
);
forAll(volTypes.internalField(), cellI)
{
volTypes[cellI] = cellTypes[cellI];
}
volTypes.correctBoundaryConditions();
volTypes.writeObject(fmt, ver, cmp, valid);
}
{
volScalarField volZoneID
(
IOobject
(
"zoneID",
this->time().timeName(),
*this,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
*this,
dimensionedScalar(dimless, Zero),
zeroGradientFvPatchScalarField::typeName
);
const cellCellStencilObject& overlap = Stencil::New(*this);
const labelIOList& zoneID = overlap.zoneID();
forAll(zoneID, cellI)
{
volZoneID[cellI] = zoneID[cellI];
}
volZoneID.correctBoundaryConditions();
volZoneID.writeObject(fmt, ver, cmp, valid);
}
return ok;
}
// ************************************************************************* //

331
src/overset/dynamicOversetFvMesh/dynamicOversetFvMesh.H.orig
View File

@ -1,331 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2015-2017 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::dynamicOversetFvMesh
Description
dynamicFvMesh with support for overset meshes.
SourceFiles
dynamicOversetFvMesh.C
\*---------------------------------------------------------------------------*/
#ifndef dynamicOversetFvMesh_H
#define dynamicOversetFvMesh_H
#include "dynamicMotionSolverFvMesh.H"
#include "labelIOList.H"
#include "fvMeshPrimitiveLduAddressing.H"
#include "lduInterfaceFieldPtrsList.H"
#include "volFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class mapDistribute;
class lduPrimitiveProcessorInterface;
/*---------------------------------------------------------------------------*\
Class dynamicOversetFvMesh Declaration
\*---------------------------------------------------------------------------*/
class dynamicOversetFvMesh
:
public dynamicMotionSolverFvMesh
{
protected:
// Protected data
//- Select base addressing (false) or locally stored extended
// lduAddressing (true)
mutable bool active_;
//- Extended addressing (extended with local interpolation stencils)
mutable autoPtr<fvMeshPrimitiveLduAddressing> lduPtr_;
//- Added (processor)lduInterfaces for remote bits of stencil.
//PtrList<const lduInterface> remoteStencilInterfaces_;
mutable PtrList<const lduPrimitiveProcessorInterface>
remoteStencilInterfaces_;
//- Interfaces for above mesh. Contains both original and
// above added processorLduInterfaces
mutable lduInterfacePtrsList allInterfaces_;
//- Corresponding faces (in above lduPtr) to the stencil
mutable labelListList stencilFaces_;
//- From old to new face labels
mutable labelList reverseFaceMap_;
// Protected Member Functions
//- Calculate the extended lduAddressing
virtual bool updateAddressing() const;
//- Debug: print matrix
template<class Type>
void write(Ostream&, const fvMatrix<Type>&, const lduAddressing&) const;
//- Explicit interpolation of acceptor cells from donor cells
template<class T>
void interpolate(Field<T>& psi) const;
//- Explicit interpolation of acceptor cells from donor cells with
// boundary condition handling
template<class GeoField>
void interpolate(GeoField& psi) const;
//- Freeze values at holes
template<class Type>
void freezeHoles(fvMatrix<Type>&) const;
//- Get scalar interfaces of certain type
template<class GeoField, class PatchType>
lduInterfaceFieldPtrsList scalarInterfaces(const GeoField& psi) const;
//- Add interpolation to matrix (coefficients)
template<class Type>
void addInterpolation(fvMatrix<Type>&) const;
//- Solve given dictionary with settings
template<class Type>
SolverPerformance<Type> solve(fvMatrix<Type>&, const dictionary&) const;
//- Debug: correct coupled bc
template<class GeoField>
static void correctCoupledBoundaryConditions(GeoField& fld);
private:
// Private Member Functions
//- No copy construct
dynamicOversetFvMesh(const dynamicOversetFvMesh&) = delete;
//- No copy assignment
void operator=(const dynamicOversetFvMesh&) = delete;
public:
//- Runtime type information
TypeName("dynamicOversetFvMesh");
// Constructors
//- Construct from IOobject
dynamicOversetFvMesh(const IOobject& io);
//- Destructor
virtual ~dynamicOversetFvMesh();
// Member Functions
// Extended addressing
//- Return extended ldu addressing
const fvMeshPrimitiveLduAddressing& primitiveLduAddr() const;
//- Return ldu addressing. If active: is (extended)
// primitiveLduAddr
virtual const lduAddressing& lduAddr() const;
//- Return old to new face addressing
const labelList& reverseFaceMap() const
{
return reverseFaceMap_;
}
//- Return true if using extended addressing
bool active() const
{
return active_;
}
//- Enable/disable extended addressing
void active(const bool f) const
{
active_ = f;
if (active_)
{
DebugInfo<< "Switching to extended addressing with nFaces:"
<< primitiveLduAddr().lowerAddr().size()
<< endl;
}
else
{
DebugInfo<< "Switching to base addressing with nFaces:"
<< fvMesh::lduAddr().lowerAddr().size()
<< endl;
}
}
// Overset
// Explicit interpolation
virtual void interpolate(scalarField& psi) const
{
interpolate<scalar>(psi);
}
virtual void interpolate(vectorField& psi) const
{
interpolate<vector>(psi);
}
virtual void interpolate(sphericalTensorField& psi) const
{
interpolate<sphericalTensor>(psi);
}
virtual void interpolate(symmTensorField& psi) const
{
interpolate<symmTensor>(psi);
}
virtual void interpolate(tensorField& psi) const
{
interpolate<tensor>(psi);
}
virtual void interpolate(volScalarField& psi) const
{
interpolate<volScalarField>(psi);
}
virtual void interpolate(volVectorField& psi) const
{
interpolate<volVectorField>(psi);
}
virtual void interpolate(volSphericalTensorField& psi) const
{
interpolate<volSphericalTensorField>(psi);
}
virtual void interpolate(volSymmTensorField& psi) const
{
interpolate<volSymmTensorField>(psi);
}
virtual void interpolate(volTensorField& psi) const
{
interpolate<volTensorField>(psi);
}
// Implicit interpolation (matrix manipulation)
//- Solve returning the solution statistics given convergence
// tolerance. Use the given solver controls
virtual SolverPerformance<scalar> solve
(
fvMatrix<scalar>& m,
const dictionary& dict
) const
{
return solve<scalar>(m, dict);
}
//- Solve returning the solution statistics given convergence
// tolerance. Use the given solver controls
virtual SolverPerformance<vector> solve
(
fvMatrix<vector>& m,
const dictionary& dict
) const
{
return solve<vector>(m, dict);
}
//- Solve returning the solution statistics given convergence
// tolerance. Use the given solver controls
virtual SolverPerformance<symmTensor> solve
(
fvMatrix<symmTensor>& m,
const dictionary& dict
) const
{
return solve<symmTensor>(m, dict);
}
//- Solve returning the solution statistics given convergence
// tolerance. Use the given solver controls
virtual SolverPerformance<tensor> solve
(
fvMatrix<tensor>& m,
const dictionary& dict
) const
{
return solve<tensor>(m, dict);
}
//- Update the mesh for both mesh motion and topology change
virtual bool update();
//- Write using given format, version and compression
virtual bool writeObject
(
IOstream::streamFormat,
IOstream::versionNumber,
IOstream::compressionType,
const bool valid
) const;
//- Debug: check halo swap is ok
template<class GeoField>
static void checkCoupledBC(const GeoField& fld);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "dynamicOversetFvMeshTemplates.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

3
src/parallel/decompose/decompose/decompositionInformation.C
View File

@ -164,6 +164,9 @@ void Foam::decompositionInformation::printSummary(Ostream& os) const
void Foam::decompositionInformation::printDetails(Ostream& os) const
{
os << "Decomposition details with (proc faces) "
"for each processor connection"<< nl << nl;
forAll(distrib_, ownProc)
{
const labelList& subdist = distrib_[ownProc];

6
tutorials/heatTransfer/chtMultiRegionFoam/externalCoupledHeater/system/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
@ -27,9 +24,8 @@ method scotch;
coeffs
{
n (2 2 1);
//delta 0.001; // default=0.001
//order xyz; // default=xzy
dataFile "decompositionData";
}
// ************************************************************************* //

16
tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/system/decomposeParDict
View File

@ -16,11 +16,7 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
// method manual;
@ -44,4 +40,16 @@ coeffs
n (2 2 1);
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

15
tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/system/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
regions
@ -40,4 +37,16 @@ coeffs
n (2 2 1);
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

14
tutorials/heatTransfer/chtMultiRegionSimpleFoam/externalCoupledHeater/system/decomposeParDict
View File

@ -16,10 +16,18 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

15
tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/system/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
@ -37,4 +34,16 @@ scotchCoeffs
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

16
tutorials/lagrangian/reactingParcelFoam/filter/system/decomposeParDict
View File

@ -18,15 +18,19 @@ numberOfSubdomains 4;
method scotch;
preserveFaceZones
(
cycLeft
cycRight
);
coeffs
{
n (2 2 1);
}
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (cycLeft cycRight);
}
}
// ************************************************************************* //

67
tutorials/mesh/parallel/cavity/system/decomposeParDict
View File

@ -17,27 +17,6 @@ FoamFile
numberOfSubdomains 2;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Keep owner and neighbour of baffles on same processor (i.e. keep it
// detectable as a baffle). Baffles are two boundary face sharing the
// same points.
//preserveBaffles true;
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -80,14 +59,11 @@ multiLevelCoeffs
simpleCoeffs
{
n (2 1 1);
delta 0.001;
}
hierarchicalCoeffs
{
n (1 2 1);
delta 0.001;
order xyz;
}
metisCoeffs
@ -131,6 +107,49 @@ structuredCoeffs
method scotch;
}
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
zones
{
type preserveFaceZones;
zones (heater solid1 solid3);
enabled false;
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches;
patches (cyclic_half0 cyclic_half1);
enabled false;
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
processors
{
type singleProcessorFaceSets;
sets ((f0 -1));
enabled false;
}
//- Keep owner and neighbour of baffles on same processor
// (i.e. keep it detectable as a baffle).
// Baffles are two boundary face sharing the same points.
baffles
{
type preserveBaffles;
enabled false;
}
}
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

73
tutorials/mesh/parallel/cavity/system/decomposeParDict-5
View File

@ -17,27 +17,6 @@ FoamFile
numberOfSubdomains 5;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Keep owner and neighbour of baffles on same processor (i.e. keep it
// detectable as a baffle). Baffles are two boundary face sharing the
// same points.
//preserveBaffles true;
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -80,14 +59,11 @@ multiLevelCoeffs
simpleCoeffs
{
n (2 1 1);
delta 0.001;
}
hierarchicalCoeffs
{
n (1 2 1);
delta 0.001;
order xyz;
}
metisCoeffs
@ -123,14 +99,57 @@ manualCoeffs
structuredCoeffs
{
// Method to use on the 2D subset
method scotch;
// Patches to do 2D decomposition on. Structured mesh only; cells have
// to be in 'columns' on top of patches.
patches (movingWall);
// Method to use on the 2D subset
method scotch;
}
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
zones
{
type preserveFaceZones;
zones (heater solid1 solid3);
enabled false;
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches;
patches (cyclic_half0 cyclic_half1);
enabled false;
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
processors
{
type singleProcessorFaceSets;
sets ((f0 -1));
enabled false;
}
//- Keep owner and neighbour of baffles on same processor
// (i.e. keep it detectable as a baffle).
// Baffles are two boundary face sharing the same points.
baffles
{
type preserveBaffles;
enabled false;
}
}
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

14
tutorials/mesh/parallel/filter/system/decomposeParDict
View File

@ -18,11 +18,15 @@ numberOfSubdomains 3;
method scotch;
preserveFaceZones
(
cycLeft
cycRight
);
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (cycLeft cycRight);
}
}
// ************************************************************************* //

74
tutorials/mesh/snappyHexMesh/addLayersToFaceZone/system/decomposeParDict
View File

@ -17,27 +17,6 @@ FoamFile
numberOfSubdomains 2;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Keep owner and neighbour of baffles on same processor (i.e. keep it
// detectable as a baffle). Baffles are two boundary face sharing the
// same points.
//preserveBaffles true;
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -79,14 +58,11 @@ multiLevelCoeffs
simpleCoeffs
{
n (2 1 1);
delta 0.001;
}
hierarchicalCoeffs
{
n (1 2 1);
delta 0.001;
order xyz;
}
metisCoeffs
@ -122,14 +98,58 @@ manualCoeffs
structuredCoeffs
{
// Method to use on the 2D subset
method scotch;
// Patches to do 2D decomposition on. Structured mesh only; cells have
// to be in 'columns' on top of patches.
patches (movingWall);
// Method to use on the 2D subset
method scotch;
}
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
zones
{
type preserveFaceZones;
zones (heater solid1 solid3);
enabled false;
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches;
patches (cyclic_half0 cyclic_half1);
enabled false;
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
singleProcessorFaceSets
{
type singleProcessorFaceSets;
sets ((f0 -1));
enabled false;
}
//- Keep owner and neighbour of baffles on same processor
// (i.e. keep it detectable as a baffle).
// Baffles are two boundary face sharing the same points.
baffles
{
type preserveBaffles;
enabled false;
}
}
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

15
tutorials/preProcessing/createZeroDirectory/snappyMultiRegionHeater/system/bottomAir/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
@ -45,4 +42,16 @@ scotchCoeffs
//strategy "b";
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

15
tutorials/preProcessing/createZeroDirectory/snappyMultiRegionHeater/system/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
// method scotch;
method hierarchical;
// method simple;
@ -45,4 +42,16 @@ scotchCoeffs
//strategy "b";
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones;
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

15
tutorials/preProcessing/createZeroDirectory/snappyMultiRegionHeater/system/heater/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
@ -45,4 +42,16 @@ scotchCoeffs
//strategy "b";
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

15
tutorials/preProcessing/createZeroDirectory/snappyMultiRegionHeater/system/leftSolid/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
@ -45,4 +42,16 @@ scotchCoeffs
//strategy "b";
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

15
tutorials/preProcessing/createZeroDirectory/snappyMultiRegionHeater/system/rightSolid/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
@ -45,4 +42,16 @@ scotchCoeffs
//strategy "b";
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

15
tutorials/preProcessing/createZeroDirectory/snappyMultiRegionHeater/system/topAir/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
@ -45,4 +42,16 @@ scotchCoeffs
//strategy "b";
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //