void Foam::primitiveMesh::calcFaceCentresAndAreas() const
{
if (debug)
{
Pout<< "primitiveMesh::calcFaceCentresAndAreas() : "
<< "Calculating face centres and face areas"
<< endl;
}
// It is an error to attempt to recalculate faceCentres
// if the pointer is already set
if (faceCentresPtr_ || faceAreasPtr_)
{
FatalErrorIn("primitiveMesh::calcFaceCentresAndAreas() const")
<< "Face centres or face areas already calculated"
<< abort(FatalError);
}
faceCentresPtr_ = new vectorField(nFaces());
vectorField& fCtrs = *faceCentresPtr_;
faceAreasPtr_ = new vectorField(nFaces());
vectorField& fAreas = *faceAreasPtr_;
makeFaceCentresAndAreas(points(), fCtrs, fAreas);
if (debug)
{
Pout<< "primitiveMesh::calcFaceCentresAndAreas() : "
<< "Finished calculating face centres and face areas"
<< endl;
}
}
void Foam::surfMesh::checkZones()
{
// extra safety, ensure we have at some zones
// and they cover all the faces - fix start silently
surfZoneList& zones = Allocator::storedIOZones();
if (zones.size() <= 1)
{
removeZones();
}
else
{
label count = 0;
forAll(zones, zoneI)
{
zones[zoneI].start() = count;
count += zones[zoneI].size();
}
if (count < nFaces())
{
WarningInFunction
<< "more faces " << nFaces() << " than zones " << count
<< " ... extending final zone"
<< endl;
zones.last().size() += count - nFaces();
}
else if (count > size())
{
FatalErrorInFunction
<< "more zones " << count << " than faces " << nFaces()
<< exit(FatalError);
}
}
// from components
faMeshDecomposition::faMeshDecomposition(const fvMesh& mesh)
:
faMesh(mesh),
decompositionDict_
(
IOobject
(
"decomposeParDict",
time().system(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
nProcs_(readInt(decompositionDict_.lookup("numberOfSubdomains"))),
distributed_(false),
faceToProc_(nFaces()),
procFaceLabels_(nProcs_),
procMeshEdgesMap_(nProcs_),
procNInternalEdges_(nProcs_, 0),
procPatchEdgeLabels_(nProcs_),
procPatchPointAddressing_(nProcs_),
procPatchEdgeAddressing_(nProcs_),
procEdgeAddressing_(nProcs_),
procFaceAddressing_(nProcs_),
procBoundaryAddressing_(nProcs_),
procPatchSize_(nProcs_),
procPatchStartIndex_(nProcs_),
procNeighbourProcessors_(nProcs_),
procProcessorPatchSize_(nProcs_),
procProcessorPatchStartIndex_(nProcs_),
globallySharedPoints_(0),
cyclicParallel_(false)
{
if (decompositionDict_.found("distributed"))
{
distributed_ = Switch(decompositionDict_.lookup("distributed"));
}
}
bool Foam::rawTopoChangerFvMesh::update()
{
// Do mesh changes (use inflation - put new points in topoChangeMap)
Info<< "rawTopoChangerFvMesh : Checking for topology changes..."
<< endl;
// Mesh not moved/changed yet
moving(false);
topoChanging(false);
// Do any topology changes. Sets topoChanging (through polyTopoChange)
autoPtr<mapPolyMesh> topoChangeMap = topoChanger_.changeMesh(true);
bool hasChanged = topoChangeMap.valid();
if (hasChanged)
{
Info<< "rawTopoChangerFvMesh : Done topology changes..."
<< endl;
// Temporary: fix fields on patch faces created out of nothing
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Two situations:
// - internal faces inflated out of nothing
// - patch faces created out of previously internal faces
// Is face mapped in any way?
PackedBoolList mappedFace(nFaces());
const label nOldInternal = topoChangeMap().oldPatchStarts()[0];
const labelList& faceMap = topoChangeMap().faceMap();
for (label facei = 0; facei < nInternalFaces(); facei++)
{
if (faceMap[facei] >= 0)
{
mappedFace[facei] = 1;
}
}
for (label facei = nInternalFaces(); facei < nFaces(); facei++)
{
if (faceMap[facei] >= 0 && faceMap[facei] >= nOldInternal)
{
mappedFace[facei] = 1;
}
}
const List<objectMap>& fromFaces = topoChangeMap().facesFromFacesMap();
forAll(fromFaces, i)
{
mappedFace[fromFaces[i].index()] = 1;
}
const List<objectMap>& fromEdges = topoChangeMap().facesFromEdgesMap();
forAll(fromEdges, i)
{
mappedFace[fromEdges[i].index()] = 1;
}
const List<objectMap>& fromPts = topoChangeMap().facesFromPointsMap();
forAll(fromPts, i)
{
mappedFace[fromPts[i].index()] = 1;
}
// Set unmapped faces to zero
Info<< "rawTopoChangerFvMesh : zeroing unmapped boundary values."
<< endl;
zeroUnmappedValues<scalar, fvPatchField, volMesh>(mappedFace);
zeroUnmappedValues<vector, fvPatchField, volMesh>(mappedFace);
zeroUnmappedValues<sphericalTensor, fvPatchField, volMesh>(mappedFace);
zeroUnmappedValues<symmTensor, fvPatchField, volMesh>(mappedFace);
zeroUnmappedValues<tensor, fvPatchField, volMesh>(mappedFace);
// Special handling for phi: set unmapped faces to recreated phi
Info<< "rawTopoChangerFvMesh :"
<< " recreating phi for unmapped boundary values." << endl;
const volVectorField& U = lookupObject<volVectorField>("U");
surfaceScalarField& phi = const_cast<surfaceScalarField&>
(
lookupObject<surfaceScalarField>("phi")
);
setUnmappedValues
(
phi,
mappedFace,
(linearInterpolate(U) & Sf())()
);
if (topoChangeMap().hasMotionPoints())
{
pointField newPoints = topoChangeMap().preMotionPoints();
// Give the meshModifiers opportunity to modify points
Info<< "rawTopoChangerFvMesh :"
<< " calling modifyMotionPoints." << endl;
topoChanger_.modifyMotionPoints(newPoints);
// Actually move points
Info<< "rawTopoChangerFvMesh :"
<< " calling movePoints." << endl;
movePoints(newPoints);
}
}
else
{
//Pout<< "rawTopoChangerFvMesh :"
// << " no topology changes..." << endl;
}
return hasChanged;
nCells++;
// Reset the primitiveMesh with the sizes of the primitive arrays
primitiveMesh::reset
(
points_.size(),
neighbour_.size(),
owner_.size(),
nCells
);
string meshInfo =
"nPoints:" + Foam::name(nPoints())
+ " nCells:" + Foam::name(this->nCells())
+ " nFaces:" + Foam::name(nFaces())
+ " nInternalFaces:" + Foam::name(nInternalFaces());
owner_.note() = meshInfo;
neighbour_.note() = meshInfo;
}
void Foam::polyMesh::initMesh(cellList& c)
{
if (debug)
{
Info<< "void polyMesh::initMesh(cellList& c) : "
<< "calculating owner-neighbour arrays" << endl;
}
Foam::tmp<Foam::scalargpuField> Foam::fvMesh::movePoints(const pointgpuField& p)
{
// Grab old time volumes if the time has been incremented
// This will update V0, V00
if (curTimeIndex_ < time().timeIndex())
{
storeOldVol(V().getField());
}
//TODO implement
return tmp<scalargpuField>(new scalargpuField(nFaces()));
/*
if (!phiPtr_)
{
// Create mesh motion flux
phiPtr_ = new surfaceScalarField
(
IOobject
(
"meshPhi",
this->time().timeName(),
*this,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
*this,
dimVolume/dimTime
);
}
else
{
// Grab old time mesh motion fluxes if the time has been incremented
if (phiPtr_->timeIndex() != time().timeIndex())
{
phiPtr_->oldTime();
}
}
surfaceScalarField& phi = *phiPtr_;
// Move the polyMesh and set the mesh motion fluxes to the swept-volumes
scalar rDeltaT = 1.0/time().deltaTValue();
tmp<scalargpuField> tsweptVols = polyMesh::movePoints(p);
scalargpuField& sweptVols = tsweptVols();
phi.internalField() = scalarField::subField(sweptVols, nInternalFaces());
phi.internalField() *= rDeltaT;
const fvPatchList& patches = boundary();
forAll(patches, patchI)
{
phi.boundaryField()[patchI] = patches[patchI].patchSlice(sweptVols);
phi.boundaryField()[patchI] *= rDeltaT;
}
// Update or delete the local geometric properties as early as possible so
// they can be used if necessary. These get recreated here instead of
// demand driven since they might do parallel transfers which can conflict
// with when they're actually being used.
// Note that between above "polyMesh::movePoints(p)" and here nothing
// should use the local geometric properties.
updateGeomNotOldVol();
// Update other local data
boundary_.movePoints();
surfaceInterpolation::movePoints();
meshObject::movePoints<fvMesh>(*this);
meshObject::movePoints<lduMesh>(*this);
return tsweptVols;
*/
}
void Foam::fvMesh::mapFields(const mapPolyMesh& meshMap)
{
if (debug)
{
Info<< "fvMesh::mapFields :"
<< " nOldCells:" << meshMap.nOldCells()
<< " nCells:" << nCells()
<< " nOldFaces:" << meshMap.nOldFaces()
<< " nFaces:" << nFaces()
<< endl;
}
// We require geometric properties valid for the old mesh
if
(
meshMap.cellMap().size() != nCells()
|| meshMap.faceMap().size() != nFaces()
)
{
FatalErrorIn("fvMesh::mapFields(const mapPolyMesh&)")
<< "mapPolyMesh does not correspond to the old mesh."
<< " nCells:" << nCells()
<< " cellMap:" << meshMap.cellMap().size()
<< " nOldCells:" << meshMap.nOldCells()
<< " nFaces:" << nFaces()
<< " faceMap:" << meshMap.faceMap().size()
<< " nOldFaces:" << meshMap.nOldFaces()
<< exit(FatalError);
}
// Create a mapper
const fvMeshMapper mapper(*this, meshMap);
// Map all the volFields in the objectRegistry
MapGeometricFields<scalar, fvPatchField, fvMeshMapper, volMesh>
(mapper);
MapGeometricFields<vector, fvPatchField, fvMeshMapper, volMesh>
(mapper);
MapGeometricFields<sphericalTensor, fvPatchField, fvMeshMapper, volMesh>
(mapper);
MapGeometricFields<symmTensor, fvPatchField, fvMeshMapper, volMesh>
(mapper);
MapGeometricFields<tensor, fvPatchField, fvMeshMapper, volMesh>
(mapper);
// Map all the surfaceFields in the objectRegistry
MapGeometricFields<scalar, fvsPatchField, fvMeshMapper, surfaceMesh>
(mapper);
MapGeometricFields<vector, fvsPatchField, fvMeshMapper, surfaceMesh>
(mapper);
MapGeometricFields<symmTensor, fvsPatchField, fvMeshMapper, surfaceMesh>
(mapper);
MapGeometricFields<symmTensor, fvsPatchField, fvMeshMapper, surfaceMesh>
(mapper);
MapGeometricFields<tensor, fvsPatchField, fvMeshMapper, surfaceMesh>
(mapper);
// Map all the dimensionedFields in the objectRegistry
MapDimensionedFields<scalar, fvMeshMapper, volMesh>(mapper);
MapDimensionedFields<vector, fvMeshMapper, volMesh>(mapper);
MapDimensionedFields<sphericalTensor, fvMeshMapper, volMesh>(mapper);
MapDimensionedFields<symmTensor, fvMeshMapper, volMesh>(mapper);
MapDimensionedFields<tensor, fvMeshMapper, volMesh>(mapper);
// Map all the clouds in the objectRegistry
mapClouds(*this, meshMap);
//TODO implement on gpu
/*
const labelList& cellMap = meshMap.cellMap();
// Map the old volume. Just map to new cell labels.
if (V0Ptr_)
{
scalargpuField& V0 = (*V0Ptr_).getField();
scalargpuField savedV0(V0);
V0.setSize(nCells());
forAll(V0, i)
{
if (cellMap[i] > -1)
{
V0[i] = savedV0[cellMap[i]];
}
else
{
V0[i] = 0.0;
}
}
// Inject volume of merged cells
label nMerged = 0;
forAll(meshMap.reverseCellMap(), oldCellI)
{
label index = meshMap.reverseCellMap()[oldCellI];
if (index < -1)
{
label cellI = -index-2;
V0[cellI] += savedV0[oldCellI];
nMerged++;
}
}
if (debug)
{
Info<< "Mapping old time volume V0. Merged "
<< nMerged << " out of " << nCells() << " cells" << endl;
}
}
// Map the old-old volume. Just map to new cell labels.
if (V00Ptr_)
{
scalargpuField& V00 = (*V00Ptr_).getField();
scalargpuField savedV00(V00);
V00.setSize(nCells());
forAll(V00, i)
{
if (cellMap[i] > -1)
{
V00[i] = savedV00[cellMap[i]];
}
else
{
V00[i] = 0.0;
}
}
// Inject volume of merged cells
label nMerged = 0;
forAll(meshMap.reverseCellMap(), oldCellI)
{
label index = meshMap.reverseCellMap()[oldCellI];
if (index < -1)
{
label cellI = -index-2;
V00[cellI] += savedV00[oldCellI];
nMerged++;
}
}
if (debug)
{
Info<< "Mapping old time volume V00. Merged "
<< nMerged << " out of " << nCells() << " cells" << endl;
}
}
*/
}
void dynamicRefineFvMesh::calculateProtectedCells
(
PackedBoolList& unrefineableCell
) const
{
if (protectedCell_.empty())
{
unrefineableCell.clear();
return;
}
const labelList& cellLevel = meshCutter_.cellLevel();
unrefineableCell = protectedCell_;
// Get neighbouring cell level
labelList neiLevel(nFaces()-nInternalFaces());
for (label faceI = nInternalFaces(); faceI < nFaces(); faceI++)
{
neiLevel[faceI-nInternalFaces()] = cellLevel[faceOwner()[faceI]];
}
syncTools::swapBoundaryFaceList(*this, neiLevel, false);
while (true)
{
// Pick up faces on border of protected cells
boolList seedFace(nFaces(), false);
forAll(faceNeighbour(), faceI)
{
label own = faceOwner()[faceI];
bool ownProtected = (unrefineableCell.get(own) == 1);
label nei = faceNeighbour()[faceI];
bool neiProtected = (unrefineableCell.get(nei) == 1);
if (ownProtected && (cellLevel[nei] > cellLevel[own]))
{
seedFace[faceI] = true;
}
else if (neiProtected && (cellLevel[own] > cellLevel[nei]))
{
seedFace[faceI] = true;
}
}
for (label faceI = nInternalFaces(); faceI < nFaces(); faceI++)
{
label own = faceOwner()[faceI];
bool ownProtected = (unrefineableCell.get(own) == 1);
if
(
ownProtected
&& (neiLevel[faceI-nInternalFaces()] > cellLevel[own])
)
{
seedFace[faceI] = true;
}
}
syncTools::syncFaceList(*this, seedFace, orEqOp<bool>(), false);
// Extend unrefineableCell
bool hasExtended = false;
for (label faceI = 0; faceI < nInternalFaces(); faceI++)
{
if (seedFace[faceI])
{
label own = faceOwner()[faceI];
if (unrefineableCell.get(own) == 0)
{
unrefineableCell.set(own, 1);
hasExtended = true;
}
label nei = faceNeighbour()[faceI];
if (unrefineableCell.get(nei) == 0)
{
unrefineableCell.set(nei, 1);
hasExtended = true;
}
}
}
for (label faceI = nInternalFaces(); faceI < nFaces(); faceI++)
{
if (seedFace[faceI])
{
label own = faceOwner()[faceI];
if (unrefineableCell.get(own) == 0)
{
unrefineableCell.set(own, 1);
hasExtended = true;
}
}
}
if (!returnReduce(hasExtended, orOp<bool>()))
{
break;
}
}
void decomposeFaces::decomposeMeshFaces(const boolList& decomposeFace)
{
done_ = false;
newFacesForFace_.setSize(mesh_.faces().size());
forAll(newFacesForFace_, fI)
newFacesForFace_.setRowSize(fI, 0);
const label nIntFaces = mesh_.nInternalFaces();
label nFaces(0), nPoints = mesh_.points().size();
point p;
pointFieldPMG& points = mesh_.points();
forAll(decomposeFace, fI)
if( decomposeFace[fI] )
++nFaces;
points.setSize(nPoints + nFaces);
polyMeshGenModifier meshModifier(mesh_);
faceListPMG& faces = meshModifier.facesAccess();
if( decomposeFace.size() != faces.size() )
FatalErrorIn
(
"void decomposeFaces::decomposeMeshFaces(const boolList&)"
) << "Incorrect size of the decomposeFace list!" << abort(FatalError);
nFaces = 0;
VRWGraph newFaces;
//- decompose internal faces
for(label faceI=0;faceI<nIntFaces;++faceI)
{
const face& f = faces[faceI];
if( decomposeFace[faceI] )
{
# ifdef DEBUGDec
Info << "Decomposing internal face " << faceI << " with nodes "
<< f << endl;
# endif
FixedList<label, 3> newF;
forAll(f, pI)
{
newF[0] = f[pI];
newF[1] = f.nextLabel(pI);
newF[2] = nPoints;
# ifdef DEBUGDec
Info << "Storing face " << newF << " with label "
<< nFaces << endl;
# endif
newFaces.appendList(newF);
newFacesForFace_.append(faceI, nFaces++);
}
p = f.centre(points);
points[nPoints] = p;
++nPoints;
}
else
{
