mirror of
https://develop.openfoam.com/Development/openfoam.git
synced 2025-11-28 03:28:01 +00:00
Merge remote branch 'OpenCFD/master' into olesenm
Conflicts: src/finiteVolume/fields/fvPatchFields/derived/timeVaryingMappedFixedValue/timeVaryingMappedFixedValueFvPatchField.C
This commit is contained in:
Mark Olesen
@ -62,7 +62,6 @@ Usage
|
||||
#include "OSspecific.H"
|
||||
#include "fvCFD.H"
|
||||
#include "IOobjectList.H"
|
||||
#include "processorFvPatchFields.H"
|
||||
#include "domainDecomposition.H"
|
||||
#include "labelIOField.H"
|
||||
#include "scalarIOField.H"
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
/*--------------------------------*- C++ -*----------------------------------*\
|
||||
| ========= | |
|
||||
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
|
||||
| \\ / O peration | Version: 1.6 |
|
||||
| \\ / A nd | Web: www.OpenFOAM.org |
|
||||
| \\/ M anipulation | |
|
||||
\*---------------------------------------------------------------------------*/
|
||||
/*-------------------------------*- C++ -*---------------------------------*\
|
||||
| ========= |
|
||||
| \\ / OpenFOAM |
|
||||
| \\ / |
|
||||
| \\ / The Open Source CFD Toolbox |
|
||||
| \\/ http://www.OpenFOAM.org |
|
||||
\*-------------------------------------------------------------------------*/
|
||||
FoamFile
|
||||
{
|
||||
version 2.0;
|
||||
@ -25,7 +25,7 @@ numberOfSubdomains 4;
|
||||
|
||||
//- Keep owner and neighbour on same processor for faces in patches:
|
||||
// (makes sense only for cyclic patches)
|
||||
//preservePatches (cyclic_left_right);
|
||||
//preservePatches (cyclic_half0 cyclic_half1);
|
||||
|
||||
|
||||
method scotch;
|
||||
|
||||
@ -28,6 +28,7 @@ License
|
||||
#include "dictionary.H"
|
||||
#include "labelIOList.H"
|
||||
#include "processorPolyPatch.H"
|
||||
#include "processorCyclicPolyPatch.H"
|
||||
#include "fvMesh.H"
|
||||
#include "OSspecific.H"
|
||||
#include "Map.H"
|
||||
@ -108,7 +109,8 @@ Foam::domainDecomposition::domainDecomposition(const IOobject& io)
|
||||
procNeighbourProcessors_(nProcs_),
|
||||
procProcessorPatchSize_(nProcs_),
|
||||
procProcessorPatchStartIndex_(nProcs_),
|
||||
cyclicParallel_(false)
|
||||
procProcessorPatchSubPatchIDs_(nProcs_),
|
||||
procProcessorPatchSubPatchStarts_(nProcs_)
|
||||
{
|
||||
decompositionDict_.readIfPresent("distributed", distributed_);
|
||||
}
|
||||
@ -339,12 +341,42 @@ bool Foam::domainDecomposition::writeDecomposition()
|
||||
const labelList& curProcessorPatchStarts =
|
||||
procProcessorPatchStartIndex_[procI];
|
||||
|
||||
const labelListList& curSubPatchIDs =
|
||||
procProcessorPatchSubPatchIDs_[procI];
|
||||
|
||||
const labelListList& curSubStarts =
|
||||
procProcessorPatchSubPatchStarts_[procI];
|
||||
|
||||
const polyPatchList& meshPatches = boundaryMesh();
|
||||
|
||||
|
||||
// Count the number of inter-proc patches
|
||||
label nInterProcPatches = 0;
|
||||
forAll(curSubPatchIDs, procPatchI)
|
||||
{
|
||||
//Info<< "For processor " << procI
|
||||
// << " have to destination processor "
|
||||
// << curNeighbourProcessors[procPatchI] << endl;
|
||||
//
|
||||
//forAll(curSubPatchIDs[procPatchI], i)
|
||||
//{
|
||||
// Info<< " from patch:" << curSubPatchIDs[procPatchI][i]
|
||||
// << " starting at:" << curSubStarts[procPatchI][i]
|
||||
// << endl;
|
||||
//}
|
||||
|
||||
nInterProcPatches += curSubPatchIDs[procPatchI].size();
|
||||
}
|
||||
|
||||
//Info<< "For processor " << procI
|
||||
// << " have " << nInterProcPatches
|
||||
// << " patches to neighbouring processors" << endl;
|
||||
|
||||
|
||||
List<polyPatch*> procPatches
|
||||
(
|
||||
curPatchSizes.size()
|
||||
+ curProcessorPatchSizes.size(),
|
||||
+ nInterProcPatches, //curProcessorPatchSizes.size(),
|
||||
reinterpret_cast<polyPatch*>(0)
|
||||
);
|
||||
|
||||
@ -381,23 +413,84 @@ bool Foam::domainDecomposition::writeDecomposition()
|
||||
|
||||
forAll(curProcessorPatchSizes, procPatchI)
|
||||
{
|
||||
procPatches[nPatches] =
|
||||
new processorPolyPatch
|
||||
(
|
||||
word("procBoundary") + Foam::name(procI)
|
||||
+ word("to")
|
||||
+ Foam::name(curNeighbourProcessors[procPatchI]),
|
||||
curProcessorPatchSizes[procPatchI],
|
||||
curProcessorPatchStarts[procPatchI],
|
||||
nPatches,
|
||||
procMesh.boundaryMesh(),
|
||||
procI,
|
||||
curNeighbourProcessors[procPatchI]
|
||||
);
|
||||
const labelList& subPatchID = curSubPatchIDs[procPatchI];
|
||||
const labelList& subStarts = curSubStarts[procPatchI];
|
||||
|
||||
nPatches++;
|
||||
label curStart = curProcessorPatchStarts[procPatchI];
|
||||
|
||||
forAll(subPatchID, i)
|
||||
{
|
||||
label size =
|
||||
(
|
||||
i < subPatchID.size()-1
|
||||
? subStarts[i+1] - subStarts[i]
|
||||
: curProcessorPatchSizes[procPatchI] - subStarts[i]
|
||||
);
|
||||
|
||||
//Info<< "From processor:" << procI << endl
|
||||
// << " to processor:" << curNeighbourProcessors[procPatchI]
|
||||
// << endl
|
||||
// << " via patch:" << subPatchID[i] << endl
|
||||
// << " start :" << curStart << endl
|
||||
// << " size :" << size << endl;
|
||||
|
||||
if (subPatchID[i] == -1)
|
||||
{
|
||||
// From internal faces
|
||||
procPatches[nPatches] =
|
||||
new processorPolyPatch
|
||||
(
|
||||
word("procBoundary") + Foam::name(procI)
|
||||
+ "to"
|
||||
+ Foam::name(curNeighbourProcessors[procPatchI]),
|
||||
size,
|
||||
curStart,
|
||||
nPatches,
|
||||
procMesh.boundaryMesh(),
|
||||
procI,
|
||||
curNeighbourProcessors[procPatchI]
|
||||
);
|
||||
}
|
||||
else
|
||||
{
|
||||
// From cyclic
|
||||
const word& referPatch =
|
||||
boundaryMesh()[subPatchID[i]].name();
|
||||
|
||||
procPatches[nPatches] =
|
||||
new processorCyclicPolyPatch
|
||||
(
|
||||
word("procBoundary") + Foam::name(procI)
|
||||
+ "to"
|
||||
+ Foam::name(curNeighbourProcessors[procPatchI])
|
||||
+ "through"
|
||||
+ referPatch,
|
||||
size,
|
||||
curStart,
|
||||
nPatches,
|
||||
procMesh.boundaryMesh(),
|
||||
procI,
|
||||
curNeighbourProcessors[procPatchI],
|
||||
referPatch
|
||||
);
|
||||
}
|
||||
|
||||
curStart += size;
|
||||
|
||||
nPatches++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//forAll(procPatches, patchI)
|
||||
//{
|
||||
// Pout<< " " << patchI
|
||||
// << '\t' << "name:" << procPatches[patchI]->name()
|
||||
// << '\t' << "type:" << procPatches[patchI]->type()
|
||||
// << '\t' << "size:" << procPatches[patchI]->size()
|
||||
// << endl;
|
||||
//}
|
||||
|
||||
// Add boundary patches
|
||||
procMesh.addPatches(procPatches);
|
||||
|
||||
@ -663,11 +756,7 @@ bool Foam::domainDecomposition::writeDecomposition()
|
||||
|
||||
forAll(procMesh.boundaryMesh(), patchi)
|
||||
{
|
||||
if
|
||||
(
|
||||
procMesh.boundaryMesh()[patchi].type()
|
||||
== processorPolyPatch::typeName
|
||||
)
|
||||
if (isA<processorPolyPatch>(procMesh.boundaryMesh()[patchi]))
|
||||
{
|
||||
const processorPolyPatch& ppp =
|
||||
refCast<const processorPolyPatch>
|
||||
@ -745,11 +834,7 @@ bool Foam::domainDecomposition::writeDecomposition()
|
||||
// (= identity map for original patches, -1 for processor patches)
|
||||
label nMeshPatches = curPatchSizes.size();
|
||||
labelList procBoundaryAddressing(identity(nMeshPatches));
|
||||
procBoundaryAddressing.setSize
|
||||
(
|
||||
nMeshPatches+curProcessorPatchSizes.size(),
|
||||
-1
|
||||
);
|
||||
procBoundaryAddressing.setSize(nMeshPatches+nProcPatches, -1);
|
||||
|
||||
labelIOList boundaryProcAddressing
|
||||
(
|
||||
|
||||
@ -29,6 +29,7 @@ Description
|
||||
|
||||
SourceFiles
|
||||
domainDecomposition.C
|
||||
decomposeMesh.C
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
@ -78,9 +79,9 @@ class domainDecomposition
|
||||
// index is negative, the processor face is the reverse of the
|
||||
// original face. In order to do this properly, all face
|
||||
// indices will be incremented by 1 and the decremented as
|
||||
// necessary t avoid the problem of face number zero having no
|
||||
// sign.
|
||||
labelListList procFaceAddressing_;
|
||||
// necessary to avoid the problem of face number zero having no
|
||||
// sign.
|
||||
List<DynamicList<label> > procFaceAddressing_;
|
||||
|
||||
//- Labels of cells for each processor
|
||||
labelListList procCellAddressing_;
|
||||
@ -93,18 +94,23 @@ class domainDecomposition
|
||||
// Excludes inter-processor boundaries
|
||||
labelListList procPatchStartIndex_;
|
||||
|
||||
|
||||
// Per inter-processor patch information
|
||||
|
||||
//- Neighbour processor ID for inter-processor boundaries
|
||||
labelListList procNeighbourProcessors_;
|
||||
|
||||
//- Sizes for inter-processor patches
|
||||
labelListList procProcessorPatchSize_;
|
||||
|
||||
//- Start indices for inter-processor patches
|
||||
//- Start indices (in procFaceAddressing_) for inter-processor patches
|
||||
labelListList procProcessorPatchStartIndex_;
|
||||
|
||||
//- Are there cyclic-parallel faces
|
||||
bool cyclicParallel_;
|
||||
//- Sub patch IDs for inter-processor patches
|
||||
List<labelListList> procProcessorPatchSubPatchIDs_;
|
||||
|
||||
//- Sub patch sizes for inter-processor patches
|
||||
List<labelListList> procProcessorPatchSubPatchStarts_;
|
||||
|
||||
// Private Member Functions
|
||||
|
||||
@ -118,6 +124,21 @@ class domainDecomposition
|
||||
labelList& elementToZone
|
||||
);
|
||||
|
||||
//- Append single element to list
|
||||
static void append(labelList&, const label);
|
||||
|
||||
//- Add face to interProcessor patch.
|
||||
void addInterProcFace
|
||||
(
|
||||
const label facei,
|
||||
const label ownerProc,
|
||||
const label nbrProc,
|
||||
|
||||
List<Map<label> >&,
|
||||
List<DynamicList<DynamicList<label> > >&
|
||||
) const;
|
||||
|
||||
|
||||
public:
|
||||
|
||||
// Constructors
|
||||
|
||||
@ -26,7 +26,6 @@ License
|
||||
#include "domainDecomposition.H"
|
||||
#include "decompositionMethod.H"
|
||||
#include "cpuTime.H"
|
||||
#include "cyclicPolyPatch.H"
|
||||
#include "cellSet.H"
|
||||
#include "regionSplit.H"
|
||||
|
||||
|
||||
@ -39,6 +39,63 @@ Description
|
||||
|
||||
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
|
||||
|
||||
void Foam::domainDecomposition::append(labelList& lst, const label elem)
|
||||
{
|
||||
label sz = lst.size();
|
||||
lst.setSize(sz+1);
|
||||
lst[sz] = elem;
|
||||
}
|
||||
|
||||
|
||||
void Foam::domainDecomposition::addInterProcFace
|
||||
(
|
||||
const label facei,
|
||||
const label ownerProc,
|
||||
const label nbrProc,
|
||||
|
||||
List<Map<label> >& nbrToInterPatch,
|
||||
List<DynamicList<DynamicList<label> > >& interPatchFaces
|
||||
) const
|
||||
{
|
||||
Map<label>::iterator patchIter = nbrToInterPatch[ownerProc].find(nbrProc);
|
||||
|
||||
// Introduce turning index only for internal faces (are duplicated).
|
||||
label ownerIndex = facei+1;
|
||||
label nbrIndex = -(facei+1);
|
||||
|
||||
if (patchIter != nbrToInterPatch[ownerProc].end())
|
||||
{
|
||||
// Existing interproc patch. Add to both sides.
|
||||
label toNbrProcPatchI = patchIter();
|
||||
interPatchFaces[ownerProc][toNbrProcPatchI].append(ownerIndex);
|
||||
|
||||
if (isInternalFace(facei))
|
||||
{
|
||||
label toOwnerProcPatchI = nbrToInterPatch[nbrProc][ownerProc];
|
||||
interPatchFaces[nbrProc][toOwnerProcPatchI].append(nbrIndex);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Create new interproc patches.
|
||||
label toNbrProcPatchI = nbrToInterPatch[ownerProc].size();
|
||||
nbrToInterPatch[ownerProc].insert(nbrProc, toNbrProcPatchI);
|
||||
DynamicList<label> oneFace;
|
||||
oneFace.append(ownerIndex);
|
||||
interPatchFaces[ownerProc].append(oneFace);
|
||||
|
||||
if (isInternalFace(facei))
|
||||
{
|
||||
label toOwnerProcPatchI = nbrToInterPatch[nbrProc].size();
|
||||
nbrToInterPatch[nbrProc].insert(ownerProc, toOwnerProcPatchI);
|
||||
oneFace.clear();
|
||||
oneFace.append(nbrIndex);
|
||||
interPatchFaces[nbrProc].append(oneFace);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Foam::domainDecomposition::decomposeMesh()
|
||||
{
|
||||
// Decide which cell goes to which processor
|
||||
@ -60,31 +117,8 @@ void Foam::domainDecomposition::decomposeMesh()
|
||||
|
||||
Info<< "\nDistributing cells to processors" << endl;
|
||||
|
||||
// Memory management
|
||||
{
|
||||
List<SLList<label> > procCellList(nProcs_);
|
||||
|
||||
forAll(cellToProc_, celli)
|
||||
{
|
||||
if (cellToProc_[celli] >= nProcs_)
|
||||
{
|
||||
FatalErrorIn("domainDecomposition::decomposeMesh()")
|
||||
<< "Impossible processor label " << cellToProc_[celli]
|
||||
<< "for cell " << celli
|
||||
<< abort(FatalError);
|
||||
}
|
||||
else
|
||||
{
|
||||
procCellList[cellToProc_[celli]].append(celli);
|
||||
}
|
||||
}
|
||||
|
||||
// Convert linked lists into normal lists
|
||||
forAll(procCellList, procI)
|
||||
{
|
||||
procCellAddressing_[procI] = procCellList[procI];
|
||||
}
|
||||
}
|
||||
// Cells per processor
|
||||
procCellAddressing_ = invertOneToMany(nProcs_, cellToProc_);
|
||||
|
||||
Info<< "\nDistributing faces to processors" << endl;
|
||||
|
||||
@ -93,504 +127,336 @@ void Foam::domainDecomposition::decomposeMesh()
|
||||
// same processor, the face is an internal face. If they are different,
|
||||
// it belongs to both processors.
|
||||
|
||||
// Memory management
|
||||
procFaceAddressing_.setSize(nProcs_);
|
||||
|
||||
// Internal faces
|
||||
forAll (neighbour, facei)
|
||||
{
|
||||
List<SLList<label> > procFaceList(nProcs_);
|
||||
|
||||
forAll(neighbour, facei)
|
||||
if (cellToProc_[owner[facei]] == cellToProc_[neighbour[facei]])
|
||||
{
|
||||
if (cellToProc_[owner[facei]] == cellToProc_[neighbour[facei]])
|
||||
{
|
||||
// Face internal to processor
|
||||
procFaceList[cellToProc_[owner[facei]]].append(facei);
|
||||
}
|
||||
// Face internal to processor. Notice no turning index.
|
||||
procFaceAddressing_[cellToProc_[owner[facei]]].append(facei+1);
|
||||
}
|
||||
}
|
||||
|
||||
// for all processors, set the size of start index and patch size
|
||||
// lists to the number of patches in the mesh
|
||||
forAll (procPatchSize_, procI)
|
||||
{
|
||||
procPatchSize_[procI].setSize(patches.size());
|
||||
procPatchStartIndex_[procI].setSize(patches.size());
|
||||
}
|
||||
|
||||
forAll (patches, patchi)
|
||||
{
|
||||
// Reset size and start index for all processors
|
||||
forAll (procPatchSize_, procI)
|
||||
{
|
||||
procPatchSize_[procI][patchi] = 0;
|
||||
procPatchStartIndex_[procI][patchi] =
|
||||
procFaceAddressing_[procI].size();
|
||||
}
|
||||
|
||||
// Detect inter-processor boundaries
|
||||
const label patchStart = patches[patchi].start();
|
||||
|
||||
// Neighbour processor for each subdomain
|
||||
List<SLList<label> > interProcBoundaries(nProcs_);
|
||||
|
||||
// Face labels belonging to each inter-processor boundary
|
||||
List<SLList<SLList<label> > > interProcBFaces(nProcs_);
|
||||
|
||||
List<SLList<label> > procPatchIndex(nProcs_);
|
||||
|
||||
forAll(neighbour, facei)
|
||||
if (!isA<cyclicPolyPatch>(patches[patchi]))
|
||||
{
|
||||
if (cellToProc_[owner[facei]] != cellToProc_[neighbour[facei]])
|
||||
// Normal patch. Add faces to processor where the cell
|
||||
// next to the face lives
|
||||
|
||||
const unallocLabelList& patchFaceCells =
|
||||
patches[patchi].faceCells();
|
||||
|
||||
forAll (patchFaceCells, facei)
|
||||
{
|
||||
// inter - processor patch face found. Go through the list of
|
||||
// inside boundaries for the owner processor and try to find
|
||||
// this inter-processor patch.
|
||||
const label curProc = cellToProc_[patchFaceCells[facei]];
|
||||
|
||||
label ownerProc = cellToProc_[owner[facei]];
|
||||
label neighbourProc = cellToProc_[neighbour[facei]];
|
||||
// add the face without turning index
|
||||
procFaceAddressing_[curProc].append(patchStart+facei+1);
|
||||
|
||||
SLList<label>::iterator curInterProcBdrsOwnIter =
|
||||
interProcBoundaries[ownerProc].begin();
|
||||
|
||||
SLList<SLList<label> >::iterator curInterProcBFacesOwnIter =
|
||||
interProcBFaces[ownerProc].begin();
|
||||
|
||||
bool interProcBouFound = false;
|
||||
|
||||
// WARNING: Synchronous SLList iterators
|
||||
|
||||
for
|
||||
(
|
||||
;
|
||||
curInterProcBdrsOwnIter
|
||||
!= interProcBoundaries[ownerProc].end()
|
||||
&& curInterProcBFacesOwnIter
|
||||
!= interProcBFaces[ownerProc].end();
|
||||
++curInterProcBdrsOwnIter, ++curInterProcBFacesOwnIter
|
||||
)
|
||||
{
|
||||
if (curInterProcBdrsOwnIter() == neighbourProc)
|
||||
{
|
||||
// the inter - processor boundary exists. Add the face
|
||||
interProcBouFound = true;
|
||||
|
||||
curInterProcBFacesOwnIter().append(facei);
|
||||
|
||||
SLList<label>::iterator curInterProcBdrsNeiIter =
|
||||
interProcBoundaries[neighbourProc].begin();
|
||||
|
||||
SLList<SLList<label> >::iterator
|
||||
curInterProcBFacesNeiIter =
|
||||
interProcBFaces[neighbourProc].begin();
|
||||
|
||||
bool neighbourFound = false;
|
||||
|
||||
// WARNING: Synchronous SLList iterators
|
||||
|
||||
for
|
||||
(
|
||||
;
|
||||
curInterProcBdrsNeiIter !=
|
||||
interProcBoundaries[neighbourProc].end()
|
||||
&& curInterProcBFacesNeiIter !=
|
||||
interProcBFaces[neighbourProc].end();
|
||||
++curInterProcBdrsNeiIter,
|
||||
++curInterProcBFacesNeiIter
|
||||
)
|
||||
{
|
||||
if (curInterProcBdrsNeiIter() == ownerProc)
|
||||
{
|
||||
// boundary found. Add the face
|
||||
neighbourFound = true;
|
||||
|
||||
curInterProcBFacesNeiIter().append(facei);
|
||||
}
|
||||
|
||||
if (neighbourFound) break;
|
||||
}
|
||||
|
||||
if (interProcBouFound && !neighbourFound)
|
||||
{
|
||||
FatalErrorIn("domainDecomposition::decomposeMesh()")
|
||||
<< "Inconsistency in inter - "
|
||||
<< "processor boundary lists for processors "
|
||||
<< ownerProc << " and " << neighbourProc
|
||||
<< abort(FatalError);
|
||||
}
|
||||
}
|
||||
|
||||
if (interProcBouFound) break;
|
||||
}
|
||||
|
||||
if (!interProcBouFound)
|
||||
{
|
||||
// inter - processor boundaries do not exist and need to
|
||||
// be created
|
||||
|
||||
// set the new addressing information
|
||||
|
||||
// owner
|
||||
interProcBoundaries[ownerProc].append(neighbourProc);
|
||||
interProcBFaces[ownerProc].append(SLList<label>(facei));
|
||||
|
||||
// neighbour
|
||||
interProcBoundaries[neighbourProc].append(ownerProc);
|
||||
interProcBFaces[neighbourProc].append(SLList<label>(facei));
|
||||
}
|
||||
// increment the number of faces for this patch
|
||||
procPatchSize_[curProc][patchi]++;
|
||||
}
|
||||
}
|
||||
|
||||
// Loop through patches. For cyclic boundaries detect inter-processor
|
||||
// faces; for all other, add faces to the face list and remember start
|
||||
// and size of all patches.
|
||||
|
||||
// for all processors, set the size of start index and patch size
|
||||
// lists to the number of patches in the mesh
|
||||
forAll(procPatchSize_, procI)
|
||||
else
|
||||
{
|
||||
procPatchSize_[procI].setSize(patches.size());
|
||||
procPatchStartIndex_[procI].setSize(patches.size());
|
||||
}
|
||||
const cyclicPolyPatch& pp = refCast<const cyclicPolyPatch>
|
||||
(
|
||||
patches[patchi]
|
||||
);
|
||||
// cyclic: check opposite side on this processor
|
||||
const unallocLabelList& patchFaceCells = pp.faceCells();
|
||||
|
||||
forAll(patches, patchi)
|
||||
{
|
||||
// Reset size and start index for all processors
|
||||
forAll(procPatchSize_, procI)
|
||||
const unallocLabelList& nbrPatchFaceCells =
|
||||
pp.neighbPatch().faceCells();
|
||||
|
||||
forAll (patchFaceCells, facei)
|
||||
{
|
||||
procPatchSize_[procI][patchi] = 0;
|
||||
procPatchStartIndex_[procI][patchi] =
|
||||
procFaceList[procI].size();
|
||||
}
|
||||
|
||||
const label patchStart = patches[patchi].start();
|
||||
|
||||
if (!isA<cyclicPolyPatch>(patches[patchi]))
|
||||
{
|
||||
// Normal patch. Add faces to processor where the cell
|
||||
// next to the face lives
|
||||
|
||||
const unallocLabelList& patchFaceCells =
|
||||
patches[patchi].faceCells();
|
||||
|
||||
forAll(patchFaceCells, facei)
|
||||
const label curProc = cellToProc_[patchFaceCells[facei]];
|
||||
const label nbrProc = cellToProc_[nbrPatchFaceCells[facei]];
|
||||
if (curProc == nbrProc)
|
||||
{
|
||||
const label curProc = cellToProc_[patchFaceCells[facei]];
|
||||
|
||||
// add the face
|
||||
procFaceList[curProc].append(patchStart + facei);
|
||||
|
||||
// add the face without turning index
|
||||
procFaceAddressing_[curProc].append(patchStart+facei+1);
|
||||
// increment the number of faces for this patch
|
||||
procPatchSize_[curProc][patchi]++;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Cyclic patch special treatment
|
||||
|
||||
const polyPatch& cPatch = patches[patchi];
|
||||
|
||||
const label cycOffset = cPatch.size()/2;
|
||||
|
||||
// Set reference to faceCells for both patches
|
||||
const labelList::subList firstFaceCells
|
||||
(
|
||||
cPatch.faceCells(),
|
||||
cycOffset
|
||||
);
|
||||
|
||||
const labelList::subList secondFaceCells
|
||||
(
|
||||
cPatch.faceCells(),
|
||||
cycOffset,
|
||||
cycOffset
|
||||
);
|
||||
|
||||
forAll(firstFaceCells, facei)
|
||||
{
|
||||
if
|
||||
(
|
||||
cellToProc_[firstFaceCells[facei]]
|
||||
!= cellToProc_[secondFaceCells[facei]]
|
||||
)
|
||||
{
|
||||
// This face becomes an inter-processor boundary face
|
||||
// inter - processor patch face found. Go through
|
||||
// the list of inside boundaries for the owner
|
||||
// processor and try to find this inter-processor
|
||||
// patch.
|
||||
|
||||
cyclicParallel_ = true;
|
||||
|
||||
label ownerProc = cellToProc_[firstFaceCells[facei]];
|
||||
label neighbourProc =
|
||||
cellToProc_[secondFaceCells[facei]];
|
||||
|
||||
SLList<label>::iterator curInterProcBdrsOwnIter =
|
||||
interProcBoundaries[ownerProc].begin();
|
||||
|
||||
SLList<SLList<label> >::iterator
|
||||
curInterProcBFacesOwnIter =
|
||||
interProcBFaces[ownerProc].begin();
|
||||
|
||||
bool interProcBouFound = false;
|
||||
|
||||
// WARNING: Synchronous SLList iterators
|
||||
|
||||
for
|
||||
(
|
||||
;
|
||||
curInterProcBdrsOwnIter !=
|
||||
interProcBoundaries[ownerProc].end()
|
||||
&& curInterProcBFacesOwnIter !=
|
||||
interProcBFaces[ownerProc].end();
|
||||
++curInterProcBdrsOwnIter,
|
||||
++curInterProcBFacesOwnIter
|
||||
)
|
||||
{
|
||||
if (curInterProcBdrsOwnIter() == neighbourProc)
|
||||
{
|
||||
// the inter - processor boundary exists.
|
||||
// Add the face
|
||||
interProcBouFound = true;
|
||||
|
||||
curInterProcBFacesOwnIter().append
|
||||
(patchStart + facei);
|
||||
|
||||
SLList<label>::iterator curInterProcBdrsNeiIter
|
||||
= interProcBoundaries[neighbourProc].begin();
|
||||
|
||||
SLList<SLList<label> >::iterator
|
||||
curInterProcBFacesNeiIter =
|
||||
interProcBFaces[neighbourProc].begin();
|
||||
|
||||
bool neighbourFound = false;
|
||||
|
||||
// WARNING: Synchronous SLList iterators
|
||||
|
||||
for
|
||||
(
|
||||
;
|
||||
curInterProcBdrsNeiIter
|
||||
!= interProcBoundaries[neighbourProc].end()
|
||||
&& curInterProcBFacesNeiIter
|
||||
!= interProcBFaces[neighbourProc].end();
|
||||
++curInterProcBdrsNeiIter,
|
||||
++curInterProcBFacesNeiIter
|
||||
)
|
||||
{
|
||||
if (curInterProcBdrsNeiIter() == ownerProc)
|
||||
{
|
||||
// boundary found. Add the face
|
||||
neighbourFound = true;
|
||||
|
||||
curInterProcBFacesNeiIter()
|
||||
.append
|
||||
(
|
||||
patchStart
|
||||
+ cycOffset
|
||||
+ facei
|
||||
);
|
||||
}
|
||||
|
||||
if (neighbourFound) break;
|
||||
}
|
||||
|
||||
if (interProcBouFound && !neighbourFound)
|
||||
{
|
||||
FatalErrorIn
|
||||
(
|
||||
"domainDecomposition::decomposeMesh()"
|
||||
) << "Inconsistency in inter-processor "
|
||||
<< "boundary lists for processors "
|
||||
<< ownerProc << " and " << neighbourProc
|
||||
<< " in cyclic boundary matching"
|
||||
<< abort(FatalError);
|
||||
}
|
||||
}
|
||||
|
||||
if (interProcBouFound) break;
|
||||
}
|
||||
|
||||
if (!interProcBouFound)
|
||||
{
|
||||
// inter - processor boundaries do not exist
|
||||
// and need to be created
|
||||
|
||||
// set the new addressing information
|
||||
|
||||
// owner
|
||||
interProcBoundaries[ownerProc]
|
||||
.append(neighbourProc);
|
||||
interProcBFaces[ownerProc]
|
||||
.append(SLList<label>(patchStart + facei));
|
||||
|
||||
// neighbour
|
||||
interProcBoundaries[neighbourProc]
|
||||
.append(ownerProc);
|
||||
interProcBFaces[neighbourProc]
|
||||
.append
|
||||
(
|
||||
SLList<label>
|
||||
(
|
||||
patchStart
|
||||
+ cycOffset
|
||||
+ facei
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// This cyclic face remains on the processor
|
||||
label ownerProc = cellToProc_[firstFaceCells[facei]];
|
||||
|
||||
// add the face
|
||||
procFaceList[ownerProc].append(patchStart + facei);
|
||||
|
||||
// increment the number of faces for this patch
|
||||
procPatchSize_[ownerProc][patchi]++;
|
||||
|
||||
// Note: I cannot add the other side of the cyclic
|
||||
// boundary here because this would violate the order.
|
||||
// They will be added in a separate loop below
|
||||
//
|
||||
}
|
||||
}
|
||||
|
||||
// Ordering in cyclic boundaries is important.
|
||||
// Add the other half of cyclic faces for cyclic boundaries
|
||||
// that remain on the processor
|
||||
forAll(secondFaceCells, facei)
|
||||
{
|
||||
if
|
||||
(
|
||||
cellToProc_[firstFaceCells[facei]]
|
||||
== cellToProc_[secondFaceCells[facei]]
|
||||
)
|
||||
{
|
||||
// This cyclic face remains on the processor
|
||||
label ownerProc = cellToProc_[firstFaceCells[facei]];
|
||||
|
||||
// add the second face
|
||||
procFaceList[ownerProc].append
|
||||
(patchStart + cycOffset + facei);
|
||||
|
||||
// increment the number of faces for this patch
|
||||
procPatchSize_[ownerProc][patchi]++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Convert linked lists into normal lists
|
||||
// Add inter-processor boundaries and remember start indices
|
||||
forAll(procFaceList, procI)
|
||||
|
||||
// Done internal bits of the new mesh and the ordinary patches.
|
||||
|
||||
|
||||
// Per processor, from neighbour processor to the interprocessorpatch that
|
||||
// communicates with that neighbour.
|
||||
List<Map<label> > procNbrToInterPatch(nProcs_);
|
||||
// Per processor the faces per interprocessorpatch.
|
||||
List<DynamicList<DynamicList<label> > > interPatchFaces(nProcs_);
|
||||
|
||||
// Processor boundaries from internal faces
|
||||
forAll (neighbour, facei)
|
||||
{
|
||||
label ownerProc = cellToProc_[owner[facei]];
|
||||
label nbrProc = cellToProc_[neighbour[facei]];
|
||||
|
||||
if (ownerProc != nbrProc)
|
||||
{
|
||||
// Get internal and regular boundary processor faces
|
||||
SLList<label>& curProcFaces = procFaceList[procI];
|
||||
|
||||
// Get reference to processor face addressing
|
||||
labelList& curProcFaceAddressing = procFaceAddressing_[procI];
|
||||
|
||||
labelList& curProcNeighbourProcessors =
|
||||
procNeighbourProcessors_[procI];
|
||||
|
||||
labelList& curProcProcessorPatchSize =
|
||||
procProcessorPatchSize_[procI];
|
||||
|
||||
labelList& curProcProcessorPatchStartIndex =
|
||||
procProcessorPatchStartIndex_[procI];
|
||||
|
||||
// calculate the size
|
||||
label nFacesOnProcessor = curProcFaces.size();
|
||||
|
||||
for
|
||||
// inter - processor patch face found.
|
||||
addInterProcFace
|
||||
(
|
||||
SLList<SLList<label> >::iterator curInterProcBFacesIter =
|
||||
interProcBFaces[procI].begin();
|
||||
curInterProcBFacesIter != interProcBFaces[procI].end();
|
||||
++curInterProcBFacesIter
|
||||
)
|
||||
{
|
||||
nFacesOnProcessor += curInterProcBFacesIter().size();
|
||||
}
|
||||
facei,
|
||||
ownerProc,
|
||||
nbrProc,
|
||||
|
||||
curProcFaceAddressing.setSize(nFacesOnProcessor);
|
||||
procNbrToInterPatch,
|
||||
interPatchFaces
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Fill in the list. Calculate turning index.
|
||||
// Turning index will be -1 only for some faces on processor
|
||||
// boundaries, i.e. the ones where the current processor ID
|
||||
// is in the cell which is a face neighbour.
|
||||
// Turning index is stored as the sign of the face addressing list
|
||||
// Add the proper processor faces to the sub information. For faces
|
||||
// originating from internal faces this is always -1.
|
||||
List<labelListList> subPatchIDs(nProcs_);
|
||||
List<labelListList> subPatchStarts(nProcs_);
|
||||
forAll(interPatchFaces, procI)
|
||||
{
|
||||
label nInterfaces = interPatchFaces[procI].size();
|
||||
|
||||
label nFaces = 0;
|
||||
subPatchIDs[procI].setSize(nInterfaces, labelList(1, -1));
|
||||
subPatchStarts[procI].setSize(nInterfaces, labelList(1, 0));
|
||||
}
|
||||
|
||||
// Add internal and boundary faces
|
||||
// Remember to increment the index by one such that the
|
||||
// turning index works properly.
|
||||
forAllConstIter(SLList<label>, curProcFaces, curProcFacesIter)
|
||||
{
|
||||
curProcFaceAddressing[nFaces] = curProcFacesIter() + 1;
|
||||
nFaces++;
|
||||
}
|
||||
|
||||
// Add inter-processor boundary faces. At the beginning of each
|
||||
// patch, grab the patch start index and size
|
||||
|
||||
curProcNeighbourProcessors.setSize
|
||||
// Processor boundaries from split cyclics
|
||||
forAll (patches, patchi)
|
||||
{
|
||||
if (isA<cyclicPolyPatch>(patches[patchi]))
|
||||
{
|
||||
const cyclicPolyPatch& pp = refCast<const cyclicPolyPatch>
|
||||
(
|
||||
interProcBoundaries[procI].size()
|
||||
patches[patchi]
|
||||
);
|
||||
|
||||
curProcProcessorPatchSize.setSize
|
||||
(
|
||||
interProcBoundaries[procI].size()
|
||||
);
|
||||
// cyclic: check opposite side on this processor
|
||||
const unallocLabelList& patchFaceCells = pp.faceCells();
|
||||
const unallocLabelList& nbrPatchFaceCells =
|
||||
pp.neighbPatch().faceCells();
|
||||
|
||||
curProcProcessorPatchStartIndex.setSize
|
||||
(
|
||||
interProcBoundaries[procI].size()
|
||||
);
|
||||
|
||||
label nProcPatches = 0;
|
||||
|
||||
SLList<label>::iterator curInterProcBdrsIter =
|
||||
interProcBoundaries[procI].begin();
|
||||
|
||||
SLList<SLList<label> >::iterator curInterProcBFacesIter =
|
||||
interProcBFaces[procI].begin();
|
||||
|
||||
for
|
||||
(
|
||||
;
|
||||
curInterProcBdrsIter != interProcBoundaries[procI].end()
|
||||
&& curInterProcBFacesIter != interProcBFaces[procI].end();
|
||||
++curInterProcBdrsIter, ++curInterProcBFacesIter
|
||||
)
|
||||
// Store old sizes. Used to detect which inter-proc patches
|
||||
// have been added to.
|
||||
labelListList oldInterfaceSizes(nProcs_);
|
||||
forAll(oldInterfaceSizes, procI)
|
||||
{
|
||||
curProcNeighbourProcessors[nProcPatches] =
|
||||
curInterProcBdrsIter();
|
||||
labelList& curOldSizes = oldInterfaceSizes[procI];
|
||||
|
||||
// Get start index for processor patch
|
||||
curProcProcessorPatchStartIndex[nProcPatches] = nFaces;
|
||||
|
||||
label& curSize =
|
||||
curProcProcessorPatchSize[nProcPatches];
|
||||
|
||||
curSize = 0;
|
||||
|
||||
// add faces for this processor boundary
|
||||
|
||||
forAllConstIter
|
||||
(
|
||||
SLList<label>,
|
||||
curInterProcBFacesIter(),
|
||||
curFacesIter
|
||||
)
|
||||
curOldSizes.setSize(interPatchFaces[procI].size());
|
||||
forAll(curOldSizes, interI)
|
||||
{
|
||||
// add the face
|
||||
|
||||
// Remember to increment the index by one such that the
|
||||
// turning index works properly.
|
||||
if (cellToProc_[owner[curFacesIter()]] == procI)
|
||||
{
|
||||
curProcFaceAddressing[nFaces] = curFacesIter() + 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
// turning face
|
||||
curProcFaceAddressing[nFaces] = -(curFacesIter() + 1);
|
||||
}
|
||||
|
||||
// increment the size
|
||||
curSize++;
|
||||
|
||||
nFaces++;
|
||||
curOldSizes[interI] =
|
||||
interPatchFaces[procI][interI].size();
|
||||
}
|
||||
}
|
||||
|
||||
nProcPatches++;
|
||||
// Add faces with different owner and neighbour processors
|
||||
forAll (patchFaceCells, facei)
|
||||
{
|
||||
const label ownerProc = cellToProc_[patchFaceCells[facei]];
|
||||
const label nbrProc = cellToProc_[nbrPatchFaceCells[facei]];
|
||||
if (ownerProc != nbrProc)
|
||||
{
|
||||
// inter - processor patch face found.
|
||||
addInterProcFace
|
||||
(
|
||||
pp.start()+facei,
|
||||
ownerProc,
|
||||
nbrProc,
|
||||
procNbrToInterPatch,
|
||||
interPatchFaces
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// 1. Check if any faces added to existing interfaces
|
||||
forAll(oldInterfaceSizes, procI)
|
||||
{
|
||||
const labelList& curOldSizes = oldInterfaceSizes[procI];
|
||||
|
||||
forAll(curOldSizes, interI)
|
||||
{
|
||||
label oldSz = curOldSizes[interI];
|
||||
if (interPatchFaces[procI][interI].size() > oldSz)
|
||||
{
|
||||
// Added faces to this interface. Add an entry
|
||||
append(subPatchIDs[procI][interI], patchi);
|
||||
append(subPatchStarts[procI][interI], oldSz);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Any new interfaces
|
||||
forAll(subPatchIDs, procI)
|
||||
{
|
||||
label nIntfcs = interPatchFaces[procI].size();
|
||||
subPatchIDs[procI].setSize(nIntfcs, labelList(1, patchi));
|
||||
subPatchStarts[procI].setSize(nIntfcs, labelList(1, 0));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Shrink processor patch face addressing
|
||||
forAll(interPatchFaces, procI)
|
||||
{
|
||||
DynamicList<DynamicList<label> >& curInterPatchFaces =
|
||||
interPatchFaces[procI];
|
||||
|
||||
forAll(curInterPatchFaces, i)
|
||||
{
|
||||
curInterPatchFaces[i].shrink();
|
||||
}
|
||||
curInterPatchFaces.shrink();
|
||||
}
|
||||
|
||||
|
||||
// Sort inter-proc patch by neighbour
|
||||
labelList order;
|
||||
forAll(procNbrToInterPatch, procI)
|
||||
{
|
||||
label nInterfaces = procNbrToInterPatch[procI].size();
|
||||
|
||||
procNeighbourProcessors_[procI].setSize(nInterfaces);
|
||||
procProcessorPatchSize_[procI].setSize(nInterfaces);
|
||||
procProcessorPatchStartIndex_[procI].setSize(nInterfaces);
|
||||
procProcessorPatchSubPatchIDs_[procI].setSize(nInterfaces);
|
||||
procProcessorPatchSubPatchStarts_[procI].setSize(nInterfaces);
|
||||
|
||||
//Info<< "Processor " << procI << endl;
|
||||
|
||||
// Get sorted neighbour processors
|
||||
const Map<label>& curNbrToInterPatch = procNbrToInterPatch[procI];
|
||||
labelList nbrs = curNbrToInterPatch.toc();
|
||||
sortedOrder(nbrs, order);
|
||||
|
||||
DynamicList<DynamicList<label> >& curInterPatchFaces =
|
||||
interPatchFaces[procI];
|
||||
|
||||
forAll(order, i)
|
||||
{
|
||||
const label nbrProc = nbrs[i];
|
||||
const label interPatch = curNbrToInterPatch[nbrProc];
|
||||
|
||||
procNeighbourProcessors_[procI][i] =
|
||||
nbrProc;
|
||||
procProcessorPatchSize_[procI][i] =
|
||||
curInterPatchFaces[interPatch].size();
|
||||
procProcessorPatchStartIndex_[procI][i] =
|
||||
procFaceAddressing_[procI].size();
|
||||
|
||||
// Add size as last element to substarts and transfer
|
||||
append
|
||||
(
|
||||
subPatchStarts[procI][interPatch],
|
||||
curInterPatchFaces[interPatch].size()
|
||||
);
|
||||
procProcessorPatchSubPatchIDs_[procI][i].transfer
|
||||
(
|
||||
subPatchIDs[procI][interPatch]
|
||||
);
|
||||
procProcessorPatchSubPatchStarts_[procI][i].transfer
|
||||
(
|
||||
subPatchStarts[procI][interPatch]
|
||||
);
|
||||
|
||||
//Info<< " nbr:" << nbrProc << endl;
|
||||
//Info<< " interpatch:" << interPatch << endl;
|
||||
//Info<< " size:" << procProcessorPatchSize_[procI][i] << endl;
|
||||
//Info<< " start:" << procProcessorPatchStartIndex_[procI][i]
|
||||
// << endl;
|
||||
//Info<< " subPatches:" << procProcessorPatchSubPatchIDs_[procI][i]
|
||||
// << endl;
|
||||
//Info<< " subStarts:"
|
||||
// << procProcessorPatchSubPatchStarts_[procI][i] << endl;
|
||||
|
||||
// And add all the face labels for interPatch
|
||||
DynamicList<label>& interPatchFaces =
|
||||
curInterPatchFaces[interPatch];
|
||||
|
||||
forAll(interPatchFaces, j)
|
||||
{
|
||||
procFaceAddressing_[procI].append(interPatchFaces[j]);
|
||||
}
|
||||
interPatchFaces.clearStorage();
|
||||
}
|
||||
curInterPatchFaces.clearStorage();
|
||||
procFaceAddressing_[procI].shrink();
|
||||
}
|
||||
|
||||
|
||||
////XXXXXXX
|
||||
//// Print a bit
|
||||
// forAll(procPatchStartIndex_, procI)
|
||||
// {
|
||||
// Info<< "Processor:" << procI << endl;
|
||||
//
|
||||
// Info<< " total faces:" << procFaceAddressing_[procI].size()
|
||||
// << endl;
|
||||
//
|
||||
// const labelList& curProcPatchStartIndex = procPatchStartIndex_[procI];
|
||||
//
|
||||
// forAll(curProcPatchStartIndex, patchI)
|
||||
// {
|
||||
// Info<< " patch:" << patchI
|
||||
// << "\tstart:" << curProcPatchStartIndex[patchI]
|
||||
// << "\tsize:" << procPatchSize_[procI][patchI]
|
||||
// << endl;
|
||||
// }
|
||||
// }
|
||||
// Info<< endl;
|
||||
//
|
||||
// forAll(procNeighbourProcessors_, procI)
|
||||
// {
|
||||
// Info<< "Processor " << procI << endl;
|
||||
//
|
||||
// forAll(procNeighbourProcessors_[procI], i)
|
||||
// {
|
||||
// Info<< " nbr:" << procNeighbourProcessors_[procI][i] << endl;
|
||||
// Info<< " size:" << procProcessorPatchSize_[procI][i] << endl;
|
||||
// Info<< " start:" << procProcessorPatchStartIndex_[procI][i]
|
||||
// << endl;
|
||||
// }
|
||||
// }
|
||||
// Info<< endl;
|
||||
//
|
||||
// forAll(procFaceAddressing_, procI)
|
||||
// {
|
||||
// Info<< "Processor:" << procI << endl;
|
||||
//
|
||||
// Info<< " faces:" << procFaceAddressing_[procI] << endl;
|
||||
// }
|
||||
|
||||
|
||||
|
||||
Info<< "\nDistributing points to processors" << endl;
|
||||
// For every processor, loop through the list of faces for the processor.
|
||||
// For every face, loop through the list of points and mark the point as
|
||||
|
||||
@ -144,7 +144,11 @@ Foam::fvFieldDecomposer::fvFieldDecomposer
|
||||
{
|
||||
forAll(boundaryAddressing_, patchi)
|
||||
{
|
||||
if (boundaryAddressing_[patchi] >= 0)
|
||||
if
|
||||
(
|
||||
boundaryAddressing_[patchi] >= 0
|
||||
&& !isA<processorLduInterface>(procMesh.boundary()[patchi])
|
||||
)
|
||||
{
|
||||
patchFieldDecomposerPtrs_[patchi] = new patchFieldDecomposer
|
||||
(
|
||||
|
||||
@ -26,6 +26,8 @@ License
|
||||
#include "fvFieldDecomposer.H"
|
||||
#include "processorFvPatchField.H"
|
||||
#include "processorFvsPatchField.H"
|
||||
#include "processorCyclicFvPatchField.H"
|
||||
#include "processorCyclicFvsPatchField.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
@ -44,7 +46,7 @@ Foam::fvFieldDecomposer::decomposeField
|
||||
|
||||
forAll(boundaryAddressing_, patchi)
|
||||
{
|
||||
if (boundaryAddressing_[patchi] >= 0)
|
||||
if (patchFieldDecomposerPtrs_[patchi])
|
||||
{
|
||||
patchFields.set
|
||||
(
|
||||
@ -58,7 +60,24 @@ Foam::fvFieldDecomposer::decomposeField
|
||||
)
|
||||
);
|
||||
}
|
||||
else
|
||||
else if (isA<processorCyclicFvPatch>(procMesh_.boundary()[patchi]))
|
||||
{
|
||||
patchFields.set
|
||||
(
|
||||
patchi,
|
||||
new processorCyclicFvPatchField<Type>
|
||||
(
|
||||
procMesh_.boundary()[patchi],
|
||||
DimensionedField<Type, volMesh>::null(),
|
||||
Field<Type>
|
||||
(
|
||||
field.internalField(),
|
||||
*processorVolPatchFieldDecomposerPtrs_[patchi]
|
||||
)
|
||||
)
|
||||
);
|
||||
}
|
||||
else if (isA<processorFvPatch>(procMesh_.boundary()[patchi]))
|
||||
{
|
||||
patchFields.set
|
||||
(
|
||||
@ -75,6 +94,11 @@ Foam::fvFieldDecomposer::decomposeField
|
||||
)
|
||||
);
|
||||
}
|
||||
else
|
||||
{
|
||||
FatalErrorIn("fvFieldDecomposer::decomposeField()")
|
||||
<< "Unknown type." << abort(FatalError);
|
||||
}
|
||||
}
|
||||
|
||||
// Create the field for the processor
|
||||
@ -155,7 +179,7 @@ Foam::fvFieldDecomposer::decomposeField
|
||||
|
||||
forAll(boundaryAddressing_, patchi)
|
||||
{
|
||||
if (boundaryAddressing_[patchi] >= 0)
|
||||
if (patchFieldDecomposerPtrs_[patchi])
|
||||
{
|
||||
patchFields.set
|
||||
(
|
||||
@ -169,7 +193,24 @@ Foam::fvFieldDecomposer::decomposeField
|
||||
)
|
||||
);
|
||||
}
|
||||
else
|
||||
else if (isA<processorCyclicFvPatch>(procMesh_.boundary()[patchi]))
|
||||
{
|
||||
patchFields.set
|
||||
(
|
||||
patchi,
|
||||
new processorCyclicFvsPatchField<Type>
|
||||
(
|
||||
procMesh_.boundary()[patchi],
|
||||
DimensionedField<Type, surfaceMesh>::null(),
|
||||
Field<Type>
|
||||
(
|
||||
allFaceField,
|
||||
*processorSurfacePatchFieldDecomposerPtrs_[patchi]
|
||||
)
|
||||
)
|
||||
);
|
||||
}
|
||||
else if (isA<processorFvPatch>(procMesh_.boundary()[patchi]))
|
||||
{
|
||||
patchFields.set
|
||||
(
|
||||
@ -186,6 +227,11 @@ Foam::fvFieldDecomposer::decomposeField
|
||||
)
|
||||
);
|
||||
}
|
||||
else
|
||||
{
|
||||
FatalErrorIn("fvFieldDecomposer::decomposeField()")
|
||||
<< "Unknown type." << abort(FatalError);
|
||||
}
|
||||
}
|
||||
|
||||
// Create the field for the processor
|
||||
|
||||
Reference in New Issue
Block a user