void Foam::GAMGAgglomeration::compactLevels(const label nCreatedLevels)
{
nCells_.setSize(nCreatedLevels);
restrictAddressing_.setSize(nCreatedLevels);
nFaces_.setSize(nCreatedLevels);
faceRestrictAddressing_.setSize(nCreatedLevels);
faceFlipMap_.setSize(nCreatedLevels);
nPatchFaces_.setSize(nCreatedLevels);
patchFaceRestrictAddressing_.setSize(nCreatedLevels);
meshLevels_.setSize(nCreatedLevels);
// Have procCommunicator_ always, even if not procAgglomerating
procCommunicator_.setSize(nCreatedLevels + 1);
if (processorAgglomerate())
{
procAgglomMap_.setSize(nCreatedLevels);
agglomProcIDs_.setSize(nCreatedLevels);
procCellOffsets_.setSize(nCreatedLevels);
procFaceMap_.setSize(nCreatedLevels);
procBoundaryMap_.setSize(nCreatedLevels);
procBoundaryFaceMap_.setSize(nCreatedLevels);
procAgglomeratorPtr_().agglomerate();
}
// Print a bit
if (processorAgglomerate() && debug)
{
Info<< "GAMGAgglomeration:" << nl
<< " local agglomerator : " << type() << nl;
if (processorAgglomerate())
{
Info<< " processor agglomerator : "
<< procAgglomeratorPtr_().type() << nl
<< nl;
}
Info<< setw(36) << "nCells"
<< setw(20) << "nFaces/nCells"
<< setw(20) << "nInterfaces"
<< setw(20) << "nIntFaces/nCells"
<< setw(12) << "profile"
<< nl
<< setw(8) << "Level"
<< setw(8) << "nProcs"
<< " "
<< setw(8) << "avg"
<< setw(8) << "max"
<< " "
<< setw(8) << "avg"
<< setw(8) << "max"
<< " "
<< setw(8) << "avg"
<< setw(8) << "max"
<< " "
<< setw(8) << "avg"
<< setw(8) << "max"
//<< " "
<< setw(12) << "avg"
<< nl
<< setw(8) << "-----"
<< setw(8) << "------"
<< " "
<< setw(8) << "---"
<< setw(8) << "---"
<< " "
<< setw(8) << "---"
<< setw(8) << "---"
<< " "
<< setw(8) << "---"
<< setw(8) << "---"
<< " "
<< setw(8) << "---"
<< setw(8) << "---"
//<< " "
<< setw(12) << "---"
//<< " "
<< nl;
for (label levelI = 0; levelI <= size(); levelI++)
{
label nProcs = 0;
label nCells = 0;
scalar faceCellRatio = 0;
label nInterfaces = 0;
label nIntFaces = 0;
scalar ratio = 0.0;
scalar profile = 0.0;
if (hasMeshLevel(levelI))
{
nProcs = 1;
const lduMesh& fineMesh = meshLevel(levelI);
nCells = fineMesh.lduAddr().size();
faceCellRatio =
scalar(fineMesh.lduAddr().lowerAddr().size())/nCells;
const lduInterfacePtrsList interfaces =
fineMesh.interfaces();
forAll(interfaces, i)
{
if (interfaces.set(i))
{
nInterfaces++;
nIntFaces += interfaces[i].faceCells().size();
}
}
ratio = scalar(nIntFaces)/nCells;
profile = fineMesh.lduAddr().band().second();
}
label totNprocs = returnReduce(nProcs, sumOp<label>());
label maxNCells = returnReduce(nCells, maxOp<label>());
label totNCells = returnReduce(nCells, sumOp<label>());
scalar maxFaceCellRatio =
returnReduce(faceCellRatio, maxOp<scalar>());
scalar totFaceCellRatio =
returnReduce(faceCellRatio, sumOp<scalar>());
label maxNInt = returnReduce(nInterfaces, maxOp<label>());
label totNInt = returnReduce(nInterfaces, sumOp<label>());
scalar maxRatio = returnReduce(ratio, maxOp<scalar>());
scalar totRatio = returnReduce(ratio, sumOp<scalar>());
scalar totProfile = returnReduce(profile, sumOp<scalar>());
int oldPrecision = Info().precision(4);
Info<< setw(8) << levelI
<< setw(8) << totNprocs
<< " "
<< setw(8) << totNCells/totNprocs
<< setw(8) << maxNCells
<< " "
<< setw(8) << totFaceCellRatio/totNprocs
<< setw(8) << maxFaceCellRatio
<< " "
<< setw(8) << scalar(totNInt)/totNprocs
<< setw(8) << maxNInt
<< " "
<< setw(8) << totRatio/totNprocs
<< setw(8) << maxRatio
<< setw(12) << totProfile/totNprocs
<< nl;
Info().precision(oldPrecision);
}
Info<< endl;
}
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]);
}
}
}