void Foam::displacementMotionSolver::updateMesh(const mapPolyMesh& mpm)
{
// pointMesh already updates pointFields
motionSolver::updateMesh(mpm);
// Map points0_. Bit special since we somehow have to come up with
// a sensible points0 position for introduced points.
// Find out scaling between points0 and current points
// Get the new points either from the map or the mesh
const pointgpuField& points =
(
mpm.hasMotionPoints()
? mpm.preMotionPoints()
: mesh().points()
);
// Note: boundBox does reduce
const vector span0 = boundBox(points0_).span();
const vector span = boundBox(points).span();
vector scaleFactors(cmptDivide(span0, span));
pointField newPoints0(mpm.pointMap().size());
forAll(newPoints0, pointI)
{
label oldPointI = mpm.pointMap()[pointI];
if (oldPointI >= 0)
{
label masterPointI = mpm.reversePointMap()[oldPointI];
if (masterPointI == pointI)
{
newPoints0[pointI] = points0_[oldPointI];
}
else
{
// New point - assume motion is scaling
newPoints0[pointI] = points0_[oldPointI] + cmptMultiply
(
scaleFactors,
points[pointI] - points[masterPointI]
);
}
}
else
{
FatalErrorIn
(
"displacementMotionSolver::updateMesh"
"(const mapPolyMesh&)"
) << "Cannot determine co-ordinates of introduced vertices."
<< " New vertex " << pointI << " at co-ordinate "
<< points[pointI] << exit(FatalError);
}
}
void Foam::componentDisplacementMotionSolver::updateMesh(const mapPolyMesh& mpm)
{
// pointMesh already updates pointFields.
motionSolver::updateMesh(mpm);
// Map points0_. Bit special since we somehow have to come up with
// a sensible points0 position for introduced points.
// Find out scaling between points0 and current points
// Get the new points either from the map or the mesh
const scalarField points
(
mpm.hasMotionPoints()
? mpm.preMotionPoints().component(cmpt_)
: mesh().points().component(cmpt_)
);
// Get extents of points0 and points and determine scale
const scalar scale =
(gMax(points0_)-gMin(points0_))
/(gMax(points)-gMin(points));
scalarField newPoints0(mpm.pointMap().size());
forAll(newPoints0, pointI)
{
label oldPointI = mpm.pointMap()[pointI];
if (oldPointI >= 0)
{
label masterPointI = mpm.reversePointMap()[oldPointI];
if (masterPointI == pointI)
{
newPoints0[pointI] = points0_[oldPointI];
}
else
{
// New point. Assume motion is scaling.
newPoints0[pointI] =
points0_[oldPointI]
+ scale*(points[pointI]-points[masterPointI]);
}
}
else
{
FatalErrorIn
(
"displacementLaplacianFvMotionSolver::updateMesh"
"(const mapPolyMesh& mpm)"
) << "Cannot work out coordinates of introduced vertices."
<< " New vertex " << pointI << " at coordinate "
<< points[pointI] << exit(FatalError);
}
}
void Foam::externalDisplacementMeshMover::updateMesh(const mapPolyMesh& mpm)
{
// Renumber baffles
DynamicList<labelPair> newBaffles(baffles_.size());
forAll(baffles_, i)
{
label f0 = mpm.reverseFaceMap()[baffles_[i].first()];
label f1 = mpm.reverseFaceMap()[baffles_[i].second()];
if (f0 >= 0 && f1 >= 0)
{
newBaffles.append(labelPair(f0, f1));
}
}
void Foam::fvMesh::mapOldVolumes(const mapPolyMesh& meshMap)
{
const labelList& cellMap = meshMap.cellMap();
// Map the old volume. Just map to new cell labels.
if (V0Ptr_)
{
if (debug)
{
InfoIn("void fvMesh::mapOldVolumes(const mapPolyMesh& meshMap)")
<< "Mapping old cell volumes." << endl;
}
scalarField& V0 = *V0Ptr_;
scalarField savedV0(V0);
V0.setSize(nCells());
forAll (V0, i)
{
if (cellMap[i] > -1)
{
V0[i] = savedV0[cellMap[i]];
}
else
{
V0[i] = 0.0;
}
}
}
// Map the old-old volume. Just map to new cell labels.
if (V00Ptr_)
{
if (debug)
{
InfoIn("void fvMesh::mapOldVolumes(const mapPolyMesh& meshMap)")
<< "Mapping old-old cell volumes." << endl;
}
scalarField& V00 = *V00Ptr_;
scalarField savedV00(V00);
V00.setSize(nCells());
forAll (V00, i)
{
if (cellMap[i] > -1)
{
V00[i] = savedV00[cellMap[i]];
}
else
{
V00[i] = 0.0;
}
}
}
}
void Foam::OutputFilterFunctionObject<OutputFilter>::updateMesh
(
const mapPolyMesh& mpm
)
{
if (active() && mpm.mesh().name() == regionName_)
{
ptr_->updateMesh(mpm);
}
}
void Foam::polyMesh::updateMesh(const mapPolyMesh& mpm)
{
// Update zones. Since boundary depends on zones, they need to be
// updated first. HJ, 20/May/2014
pointZones_.updateMesh();
faceZones_.updateMesh();
cellZones_.updateMesh();
// Update boundaryMesh (note that patches themselves are already ok)
boundary_.updateMesh();
// Clear out parallel data. HJ, 27/Nov/2009
deleteDemandDrivenData(globalMeshDataPtr_);
setInstance(time().timeName());
// Map the old motion points if present
if (oldAllPointsPtr_)
{
// Make a copy of the original points
pointField oldMotionPoints = *oldAllPointsPtr_;
pointField& newMotionPoints = *oldAllPointsPtr_;
// Resize the list to new size
newMotionPoints.setSize(allPoints_.size());
// Map the list
newMotionPoints.map(oldMotionPoints, mpm.pointMap());
// Reset old points if present
if (oldPointsPtr_)
{
oldPointsPtr_->reset(*oldAllPointsPtr_, nPoints());
}
}
// Reset valid directions (could change by faces put into empty patches)
geometricD_ = Vector<label>::zero;
solutionD_ = Vector<label>::zero;
// Update all function objects
// Moved from fvMesh.C in 1.6.x merge. HJ, 29/Aug/2010
meshObjectBase::allUpdateTopology<polyMesh>(*this, mpm);
}
void cellSet::updateMesh(const mapPolyMesh& morphMap)
{
updateLabels(morphMap.reverseCellMap());
}
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 setUpdater::updateSets(const mapPolyMesh& morphMap) const
{
//
// Update all sets in memory.
//
HashTable<const Type*> memSets =
morphMap.mesh().objectRegistry::lookupClass<Type>();
for
(
typename HashTable<const Type*>::iterator iter = memSets.begin();
iter != memSets.end();
++iter
)
{
Type& set = const_cast<Type&>(*iter());
if (debug)
{
Pout<< "Set:" << set.name() << " size:" << set.size()
<< " updated in memory" << endl;
}
set.updateMesh(morphMap);
// Write or not? Debatable.
set.write();
}
//
// Update all sets on disk
//
// Get last valid mesh (discard points-only change)
IOobjectList Objects
(
morphMap.mesh().time(),
morphMap.mesh().time().findInstance
(
morphMap.mesh().meshDir(),
"faces"
),
"polyMesh/sets"
);
IOobjectList fileSets(Objects.lookupClass(Type::typeName));
for
(
IOobjectList::const_iterator iter = fileSets.begin();
iter != fileSets.end();
++iter
)
{
if (!memSets.found(iter.key()))
{
// Not in memory. Load it.
Type set(*iter());
if (debug)
{
Pout<< "Set:" << set.name() << " size:" << set.size()
<< " updated on disk" << endl;
}
set.updateMesh(morphMap);
set.write();
}
else
{
if (debug)
{
Pout<< "Set:" << iter.key() << " already updated from memory"
<< endl;
}
}
}
}
void Foam::fvMesh::mapFields(const mapPolyMesh& meshMap)
{
// 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 clouds in the objectRegistry
mapClouds(*this, meshMap);
const labelList& cellMap = meshMap.cellMap();
// Map the old volume. Just map to new cell labels.
if (V0Ptr_)
{
scalarField& V0 = *V0Ptr_;
scalarField savedV0(V0);
V0.setSize(nCells());
forAll(V0, i)
{
if (cellMap[i] > -1)
{
V0[i] = savedV0[cellMap[i]];
}
else
{
V0[i] = 0.0;
}
}
}
// Map the old-old volume. Just map to new cell labels.
if (V00Ptr_)
{
scalarField& V00 = *V00Ptr_;
scalarField savedV00(V00);
V00.setSize(nCells());
forAll(V00, i)
{
if (cellMap[i] > -1)
{
V00[i] = savedV00[cellMap[i]];
}
else
{
V00[i] = 0.0;
}
}
}
}
void Foam::displacementSBRStressFvMotionSolver::updateMesh
(
const mapPolyMesh& mpm
)
{
fvMotionSolver::updateMesh(mpm);
// Map points0_
// Map points0_. Bit special since we somehow have to come up with
// a sensible points0 position for introduced points.
// Find out scaling between points0 and current points
// Get the new points either from the map or the mesh
const pointField& points =
(
mpm.hasMotionPoints()
? mpm.preMotionPoints()
: fvMesh_.points()
);
// Note: boundBox does reduce
const boundBox bb0(points0_, true);
const vector span0(bb0.max()-bb0.min());
const boundBox bb(points, true);
const vector span(bb.max()-bb.min());
vector scaleFactors(cmptDivide(span0, span));
pointField newPoints0(mpm.pointMap().size());
forAll(newPoints0, pointI)
{
label oldPointI = mpm.pointMap()[pointI];
if (oldPointI >= 0)
{
label masterPointI = mpm.reversePointMap()[oldPointI];
if (masterPointI == pointI)
{
newPoints0[pointI] = points0_[oldPointI];
}
else
{
// New point. Assume motion is scaling.
newPoints0[pointI] =
points0_[oldPointI]
+ cmptMultiply
(
scaleFactors,
points[pointI]-points[masterPointI]
);
}
}
else
{
FatalErrorIn
(
"displacementSBRStressFvMotionSolver::updateMesh"
"(const mapPolyMesh& mpm)"
) << "Cannot work out coordinates of introduced vertices."
<< " New vertex " << pointI << " at coordinate "
<< points[pointI] << exit(FatalError);
}
}