// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void polyDelListOfAtoms::findMolsToDel()
{
label initialSize = molCloud_.size();
label deletedMols = 0;
Info << nl << "Deleting the following molecules... " << nl << endl;
DynamicList<vector> positions;
DynamicList<scalar> rMinCollect;
forAll(molPoints_, i)
{
DynamicList<polyMolecule*> molsToDel;
IDLList<polyMolecule>::iterator mol(molCloud_.begin());
scalar rMin = GREAT;
for
(
mol = molCloud_.begin();
mol != molCloud_.end();
++mol
)
{
if(findIndex(molIds_, mol().id()) != -1)
{
vector rT = molPoints_[i];
scalar magRIJ = mag(rT-mol().position());
if(magRIJ < rMin)
{
molsToDel.clear();
rMin = magRIJ;
polyMolecule* molI = &mol();
molsToDel.append(molI);
}
}
}
forAll(molsToDel, m)
{
positions.append(molsToDel[m]->position());
rMinCollect.append(rMin);
Info << molsToDel[m]->position()
<< endl;
deletedMols++;
deleteMolFromMoleculeCloud(*molsToDel[m]);
}
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::Particle<ParticleType>::findFaces
(
const vector& position,
DynamicList<label>& faceList
) const
{
const polyMesh& mesh = cloud_.polyMesh_;
const labelList& faces = mesh.cells()[celli_];
const vector& C = mesh.cellCentres()[celli_];
faceList.clear();
forAll(faces, i)
{
label facei = faces[i];
scalar lam = lambda(C, position, facei);
if ((lam > 0) && (lam < 1.0))
{
faceList.append(facei);
}
}
// Coming from startEdgeI cross the edge to the other face
// across to the next cut edge.
bool Foam::cuttingPlane::walkCell
(
const primitiveMesh& mesh,
const UList<label>& edgePoint,
const label cellI,
const label startEdgeI,
DynamicList<label>& faceVerts
)
{
label faceI = -1;
label edgeI = startEdgeI;
label nIter = 0;
faceVerts.clear();
do
{
faceVerts.append(edgePoint[edgeI]);
// Cross edge to other face
faceI = meshTools::otherFace(mesh, cellI, faceI, edgeI);
// Find next cut edge on face.
const labelList& fEdges = mesh.faceEdges()[faceI];
label nextEdgeI = -1;
//Note: here is where we should check for whether there are more
// than 2 intersections with the face (warped/non-convex face).
// If so should e.g. decompose the cells on both faces and redo
// the calculation.
forAll(fEdges, i)
{
label edge2I = fEdges[i];
if (edge2I != edgeI && edgePoint[edge2I] != -1)
{
nextEdgeI = edge2I;
break;
}
}
if (nextEdgeI == -1)
{
// Did not find another cut edge on faceI. Do what?
WarningIn("Foam::cuttingPlane::walkCell")
<< "Did not find closed walk along surface of cell " << cellI
<< " starting from edge " << startEdgeI
<< " in " << nIter << " iterations." << nl
<< "Collected cutPoints so far:" << faceVerts
<< endl;
return false;
}
edgeI = nextEdgeI;
nIter++;
if (nIter > 1000)
{
WarningIn("Foam::cuttingPlane::walkCell")
<< "Did not find closed walk along surface of cell " << cellI
<< " starting from edge " << startEdgeI
<< " in " << nIter << " iterations." << nl
<< "Collected cutPoints so far:" << faceVerts
<< endl;
return false;
}
} while (edgeI != startEdgeI);
Foam::autoPtr<Foam::lduPrimitiveMesh>
Foam::procFacesGAMGProcAgglomeration::singleCellMesh
(
const label singleCellMeshComm,
const lduMesh& mesh,
scalarField& faceWeights
) const
{
// Count number of faces per processor
List<Map<label>> procFaces(UPstream::nProcs(mesh.comm()));
Map<label>& myNeighbours = procFaces[UPstream::myProcNo(mesh.comm())];
{
const lduInterfacePtrsList interfaces(mesh.interfaces());
forAll(interfaces, intI)
{
if (interfaces.set(intI))
{
const processorLduInterface& pp =
refCast<const processorLduInterface>
(
interfaces[intI]
);
label size = interfaces[intI].faceCells().size();
myNeighbours.insert(pp.neighbProcNo(), size);
}
}
}
Pstream::gatherList(procFaces, Pstream::msgType(), mesh.comm());
Pstream::scatterList(procFaces, Pstream::msgType(), mesh.comm());
autoPtr<lduPrimitiveMesh> singleCellMeshPtr;
if (Pstream::master(mesh.comm()))
{
// I am master
label nCells = Pstream::nProcs(mesh.comm());
DynamicList<label> l(3*nCells);
DynamicList<label> u(3*nCells);
DynamicList<scalar> weight(3*nCells);
DynamicList<label> nbrs;
DynamicList<scalar> weights;
forAll(procFaces, procI)
{
const Map<label>& neighbours = procFaces[procI];
// Add all the higher processors
nbrs.clear();
weights.clear();
forAllConstIter(Map<label>, neighbours, iter)
{
if (iter.key() > procI)
{
nbrs.append(iter.key());
weights.append(iter());
}
sort(nbrs);
forAll(nbrs, i)
{
l.append(procI);
u.append(nbrs[i]);
weight.append(weights[i]);
}
}
}
