Foam::patchInjectionBase::patchInjectionBase
(
const polyMesh& mesh,
const word& patchName
)
:
patchName_(patchName),
patchId_(mesh.boundaryMesh().findPatchID(patchName_)),
patchArea_(0.0),
patchNormal_(),
cellOwners_(),
triFace_(),
triToFace_(),
triCumulativeMagSf_(),
sumTriMagSf_(Pstream::nProcs() + 1, 0.0)
{
if (patchId_ < 0)
{
FatalErrorInFunction
<< "Requested patch " << patchName_ << " not found" << nl
<< "Available patches are: " << mesh.boundaryMesh().names() << nl
<< exit(FatalError);
}
updateMesh(mesh);
}
Foam::sampledIsoSurface::sampledIsoSurface
(
const word& name,
const polyMesh& mesh,
const dictionary& dict
)
:
sampledSurface(name, mesh, dict),
isoField_(dict.lookup("isoField")),
isoVal_(readScalar(dict.lookup("isoValue"))),
mergeTol_(dict.lookupOrDefault("mergeTol", 1e-6)),
regularise_(dict.lookupOrDefault("regularise", true)),
average_(dict.lookupOrDefault("average", false)),
zoneID_(dict.lookupOrDefault("zone", word::null), mesh.cellZones()),
exposedPatchName_(word::null),
surfPtr_(NULL),
facesPtr_(NULL),
prevTimeIndex_(-1),
storedVolFieldPtr_(NULL),
volFieldPtr_(NULL),
storedPointFieldPtr_(NULL),
pointFieldPtr_(NULL)
{
if (!sampledSurface::interpolate())
{
FatalIOErrorIn
(
"sampledIsoSurface::sampledIsoSurface"
"(const word&, const polyMesh&, const dictionary&)",
dict
) << "Non-interpolated iso surface not supported since triangles"
<< " span across cells." << exit(FatalIOError);
}
if (zoneID_.index() != -1)
{
dict.lookup("exposedPatchName") >> exposedPatchName_;
if (mesh.boundaryMesh().findPatchID(exposedPatchName_) == -1)
{
FatalIOErrorIn
(
"sampledIsoSurface::sampledIsoSurface"
"(const word&, const polyMesh&, const dictionary&)",
dict
) << "Cannot find patch " << exposedPatchName_
<< " in which to put exposed faces." << endl
<< "Valid patches are " << mesh.boundaryMesh().names()
<< exit(FatalIOError);
}
if (debug && zoneID_.index() != -1)
{
Info<< "Restricting to cellZone " << zoneID_.name()
<< " with exposed internal faces into patch "
<< exposedPatchName_ << endl;
}
}
// Construct from dictionary
Foam::thoboisValve::thoboisValve
(
const word& name,
const polyMesh& mesh,
const dictionary& dict
)
:
name_(name),
mesh_(mesh),
engineDB_(refCast<const engineTime>(mesh_.time())),
csPtr_
(
coordinateSystem::New
(
"coordinateSystem",
dict.subDict("coordinateSystem")
)
),
bottomPatch_(dict.lookup("bottomPatch"), mesh.boundaryMesh()),
poppetPatch_(dict.lookup("poppetPatch"), mesh.boundaryMesh()),
sidePatch_(dict.lookup("sidePatch"), mesh.boundaryMesh()),
stemPatch_(dict.lookup("stemPatch"), mesh.boundaryMesh()),
detachInCylinderPatch_
(
dict.lookup("detachInCylinderPatch"),
mesh.boundaryMesh()
),
detachInPortPatch_
(
dict.lookup("detachInPortPatch"),
mesh.boundaryMesh()
),
detachFacesName_(dict.lookup("detachFaces")),
liftProfile_
(
"theta",
"lift",
name_,
IFstream
(
mesh.time().path()/mesh.time().constant()/
word(dict.lookup("liftProfileFile"))
)()
),
liftProfileStart_(min(liftProfile_.x())),
liftProfileEnd_(max(liftProfile_.x())),
minLift_(readScalar(dict.lookup("minLift"))),
diameter_(readScalar(dict.lookup("diameter"))),
staticPointsName_(dict.lookup("staticPoints")),
movingPointsName_(dict.lookup("movingPoints")),
movingInternalPointsName_(dict.lookup("movingInternalPoints")),
staticCellsName_(dict.lookup("staticCells")),
movingCellsName_(dict.lookup("movingCells"))
{}
label findPatchID(const polyMesh& mesh, const word& name)
{
label patchI = mesh.boundaryMesh().findPatchID(name);
if (patchI == -1)
{
FatalErrorIn("findPatchID(const polyMesh&, const word&)")
<< "Cannot find patch " << name << endl
<< "Valid patches are " << mesh.boundaryMesh().names()
<< exit(FatalError);
}
return patchI;
}
// Adds empty patch if not yet there. Returns patchID.
label addPatch(polyMesh& mesh, const word& patchName)
{
label patchi = mesh.boundaryMesh().findPatchID(patchName);
if (patchi == -1)
{
const polyBoundaryMesh& patches = mesh.boundaryMesh();
List<polyPatch*> newPatches(patches.size() + 1);
patchi = 0;
// Copy all old patches
forAll(patches, i)
{
const polyPatch& pp = patches[i];
newPatches[patchi] =
pp.clone
(
patches,
patchi,
pp.size(),
pp.start()
).ptr();
patchi++;
}
// Add zero-sized patch
newPatches[patchi] =
new polyPatch
(
patchName,
0,
mesh.nFaces(),
patchi,
patches,
polyPatch::typeName
);
mesh.removeBoundary();
mesh.addPatches(newPatches);
Pout<< "Created patch " << patchName << " at " << patchi << endl;
}
else
{
Foam::engineVerticalValve::engineVerticalValve
(
const word& name,
const polyMesh& mesh,
const autoPtr<coordinateSystem>& valveCS,
const word& bottomPatchName,
const word& poppetPatchName,
const word& stemPatchName,
const word& curtainInPortPatchName,
const word& curtainInCylinderPatchName,
const word& detachInCylinderPatchName,
const word& detachInPortPatchName,
const labelList& detachFaces,
const graph& liftProfile,
const scalar minLift,
const scalar minTopLayer,
const scalar maxTopLayer,
const scalar minBottomLayer,
const scalar maxBottomLayer,
const scalar diameter,
const word& valveHeadPatchName,
const scalar topLayerOffset,
const scalar topLayerTol,
const scalar bottomLayerOffset,
const scalar bottomLayerTol,
const scalar detachDistance,
const scalar detachTol,
const scalar deformationLift
)
:
engineValve
(
name,
mesh,
valveCS,
bottomPatchName,
poppetPatchName,
stemPatchName,
curtainInPortPatchName,
curtainInCylinderPatchName,
detachInCylinderPatchName,
detachInPortPatchName,
detachFaces,
liftProfile,
minLift,
minTopLayer,
maxTopLayer,
minBottomLayer,
maxBottomLayer,
diameter
),
valveHeadPatch_(valveHeadPatchName, mesh.boundaryMesh()),
topLayerOffset_(topLayerOffset),
topLayerTol_(topLayerTol),
bottomLayerOffset_(bottomLayerOffset),
bottomLayerTol_(bottomLayerTol),
detachDistance_(detachDistance),
detachTol_(detachTol),
deformationLift_(deformationLift)
{}
Foam::pointMesh::pointMesh
(
const polyMesh& pMesh,
bool alwaysConstructGlobalPatch
)
:
MeshObject<polyMesh, pointMesh>(pMesh),
GeoMesh<polyMesh>(pMesh),
boundary_(*this, pMesh.boundaryMesh())
{
// Add the globalPointPatch if there are global points
if
(
alwaysConstructGlobalPatch
|| GeoMesh<polyMesh>::mesh_.globalData().nGlobalPoints()
)
{
boundary_.setSize(boundary_.size() + 1);
boundary_.set
(
boundary_.size() - 1,
new globalPointPatch
(
boundary_,
boundary_.size() - 1
)
);
}
// Calculate the geometry for the patches (transformation tensors etc.)
boundary_.calcGeometry();
}
//- (optionally destructively) construct from components
Foam::mapDistributePolyMesh::mapDistributePolyMesh
(
const polyMesh& mesh,
const label nOldPoints,
const label nOldFaces,
const label nOldCells,
labelList& oldPatchStarts,
labelList& oldPatchNMeshPoints,
labelListList& subPointMap,
labelListList& subFaceMap,
labelListList& subCellMap,
labelListList& subPatchMap,
labelListList& constructPointMap,
labelListList& constructFaceMap,
labelListList& constructCellMap,
labelListList& constructPatchMap,
const bool reUse // clone or reuse
)
:
mesh_(mesh),
nOldPoints_(nOldPoints),
nOldFaces_(nOldFaces),
nOldCells_(nOldCells),
oldPatchSizes_(oldPatchStarts.size()),
oldPatchStarts_(oldPatchStarts, reUse),
oldPatchNMeshPoints_(oldPatchNMeshPoints, reUse),
pointMap_(mesh.nPoints(), subPointMap, constructPointMap, reUse),
faceMap_(mesh.nFaces(), subFaceMap, constructFaceMap, reUse),
cellMap_(mesh.nCells(), subCellMap, constructCellMap, reUse),
patchMap_(mesh.boundaryMesh().size(), subPatchMap, constructPatchMap, reUse)
{
calcPatchSizes();
}
Foam::labelList Foam::structuredDecomp::decompose
(
const polyMesh& mesh,
const pointField& cc,
const scalarField& cWeights
)
{
const polyBoundaryMesh& pbm = mesh.boundaryMesh();
const labelHashSet patchIDs(pbm.patchSet(patches_));
label nFaces = 0;
forAllConstIter(labelHashSet, patchIDs, iter)
{
nFaces += pbm[iter.key()].size();
}
// Extract a submesh.
labelHashSet patchCells(2*nFaces);
forAllConstIter(labelHashSet, patchIDs, iter)
{
const labelUList& fc = pbm[iter.key()].faceCells();
forAll(fc, i)
{
patchCells.insert(fc[i]);
}
}
Foam::extendedFaceToCellStencil::extendedFaceToCellStencil(const polyMesh& mesh)
:
mesh_(mesh)
{
// Check for transformation - not supported.
const polyBoundaryMesh& patches = mesh.boundaryMesh();
forAll(patches, patchI)
{
if (isA<coupledPolyPatch>(patches[patchI]))
{
const coupledPolyPatch& cpp =
refCast<const coupledPolyPatch>(patches[patchI]);
if (!cpp.parallel() || cpp.separated())
{
FatalErrorIn
(
"extendedFaceToCellStencil::extendedFaceToCellStencil"
"(const polyMesh&)"
) << "Coupled patches with transformations not supported."
<< endl
<< "Problematic patch " << cpp.name() << exit(FatalError);
}
}
}
}
Foam::labelList Foam::structuredRenumber::renumber
(
const polyMesh& mesh,
const pointField& points
) const
{
if (points.size() != mesh.nCells())
{
FatalErrorInFunction
<< "Number of points " << points.size()
<< " should equal the number of cells " << mesh.nCells()
<< exit(FatalError);
}
const polyBoundaryMesh& pbm = mesh.boundaryMesh();
const labelHashSet patchIDs(pbm.patchSet(patches_));
label nFaces = 0;
forAllConstIter(labelHashSet, patchIDs, iter)
{
nFaces += pbm[iter.key()].size();
}
// Extract a submesh.
labelHashSet patchCells(2*nFaces);
forAllConstIter(labelHashSet, patchIDs, iter)
{
const labelUList& fc = pbm[iter.key()].faceCells();
forAll(fc, i)
{
patchCells.insert(fc[i]);
}
}
Foam::cellPointWeightWallModified::cellPointWeightWallModified
(
const polyMesh& mesh,
const vector& position,
const label celli,
const label facei
)
:
cellPointWeight(mesh, position, celli, facei)
{
// findTetrahedron or findTriangle will already have been called
// by the cellPointWeight constructor
if (facei >= 0)
{
const polyBoundaryMesh& bm = mesh.boundaryMesh();
label patchi = bm.whichPatch(facei);
if (patchi != -1)
{
if (isA<wallPolyPatch>(bm[patchi]))
{
// Apply cell centre value wall faces
weights_[0] = 1.0;
weights_[1] = 0.0;
weights_[2] = 0.0;
weights_[3] = 0.0;
}
}
}
}
// Construct from dictionary
Foam::engineVerticalValve::engineVerticalValve
(
const word& name,
const polyMesh& mesh,
const dictionary& dict
)
:
engineValve
(
name,
mesh,
dict
),
valveHeadPatch_
(
dict.lookup("valveHeadPatch"),
mesh.boundaryMesh()
),
topLayerOffset_(readScalar(dict.lookup("topLayerOffset"))),
topLayerTol_(readScalar(dict.lookup("topLayerTol"))),
bottomLayerOffset_(readScalar(dict.lookup("bottomLayerOffset"))),
bottomLayerTol_(readScalar(dict.lookup("bottomLayerTol"))),
detachDistance_(readScalar(dict.lookup("detachDistance"))),
detachTol_(readScalar(dict.lookup("detachTol"))),
deformationLift_(readScalar(dict.lookup("deformationLift")))
{}
Foam::sampledPatchInternalField::sampledPatchInternalField
(
const word& name,
const polyMesh& mesh,
const dictionary& dict
)
:
sampledPatch(name, mesh, dict),
mappers_(patchIDs().size())
{
const scalar distance = readScalar(dict.lookup("distance"));
forAll(patchIDs(), i)
{
label patchI = patchIDs()[i];
mappers_.set
(
i,
new directMappedPatchBase
(
mesh.boundaryMesh()[patchI],
mesh.name(), // sampleRegion
directMappedPatchBase::NEARESTCELL, // sampleMode
word::null, // samplePatch
-distance // sample inside my domain
)
);
}
void Foam::patchInjectionBase::updateMesh(const polyMesh& mesh)
{
// Set/cache the injector cells
const polyPatch& patch = mesh.boundaryMesh()[patchId_];
const pointField& points = patch.points();
cellOwners_ = patch.faceCells();
// Triangulate the patch faces and create addressing
DynamicList<label> triToFace(2*patch.size());
DynamicList<scalar> triMagSf(2*patch.size());
DynamicList<face> triFace(2*patch.size());
DynamicList<face> tris(5);
// Set zero value at the start of the tri area list
triMagSf.append(0.0);
forAll(patch, facei)
{
const face& f = patch[facei];
tris.clear();
f.triangles(points, tris);
forAll(tris, i)
{
triToFace.append(facei);
triFace.append(tris[i]);
triMagSf.append(tris[i].mag(points));
}
}
void Foam::syncTools::swapBoundaryCellPositions
(
const polyMesh& mesh,
const UList<point>& cellData,
List<point>& neighbourCellData
)
{
if (cellData.size() != mesh.nCells())
{
FatalErrorInFunction
<< "Number of cell values " << cellData.size()
<< " is not equal to the number of cells in the mesh "
<< mesh.nCells() << abort(FatalError);
}
const polyBoundaryMesh& patches = mesh.boundaryMesh();
label nBnd = mesh.nFaces()-mesh.nInternalFaces();
neighbourCellData.setSize(nBnd);
forAll(patches, patchI)
{
const polyPatch& pp = patches[patchI];
const labelUList& faceCells = pp.faceCells();
forAll(faceCells, i)
{
label bFaceI = pp.start()+i-mesh.nInternalFaces();
neighbourCellData[bFaceI] = cellData[faceCells[i]];
}
}
// Adds empty patch if not yet there. Returns patchID.
label addPatch(polyMesh& mesh, const word& patchName)
{
label patchi = mesh.boundaryMesh().findPatchID(patchName);
if (patchi == -1)
{
const polyBoundaryMesh& patches = mesh.boundaryMesh();
List<polyPatch*> newPatches(patches.size() + 1);
// Add empty patch as 0th entry (Note: only since subsetMesh wants this)
patchi = 0;
newPatches[patchi] =
new emptyPolyPatch
(
Foam::word(patchName),
0,
mesh.nInternalFaces(),
patchi,
patches,
emptyPolyPatch::typeName
);
forAll(patches, i)
{
const polyPatch& pp = patches[i];
newPatches[i+1] =
pp.clone
(
patches,
i+1,
pp.size(),
pp.start()
).ptr();
}
mesh.removeBoundary();
mesh.addPatches(newPatches);
Info<< "Created patch oldInternalFaces at " << patchi << endl;
}
else
{
Foam::pointMesh::pointMesh(const polyMesh& pMesh)
:
MeshObject<polyMesh, pointMesh>(pMesh),
GeoMesh<polyMesh>(pMesh),
boundary_(*this, pMesh.boundaryMesh())
{
// Calculate the geometry for the patches (transformation tensors etc.)
boundary_.calcGeometry();
}
void Foam::scotchDecomp::calcCSR
(
const polyMesh& mesh,
List<int>& adjncy,
List<int>& xadj
)
{
// Make Metis CSR (Compressed Storage Format) storage
// adjncy : contains neighbours (= edges in graph)
// xadj(celli) : start of information in adjncy for celli
xadj.setSize(mesh.nCells()+1);
// Initialise the number of internal faces of the cells to twice the
// number of internal faces
label nInternalFaces = 2*mesh.nInternalFaces();
// Check the boundary for coupled patches and add to the number of
// internal faces
const polyBoundaryMesh& pbm = mesh.boundaryMesh();
forAll(pbm, patchi)
{
if (isA<cyclicPolyPatch>(pbm[patchi]))
{
nInternalFaces += pbm[patchi].size();
}
}
// Create the adjncy array the size of the total number of internal and
// coupled faces
adjncy.setSize(nInternalFaces);
// Fill in xadj
// ~~~~~~~~~~~~
label freeAdj = 0;
for (label cellI = 0; cellI < mesh.nCells(); cellI++)
{
xadj[cellI] = freeAdj;
const labelList& cFaces = mesh.cells()[cellI];
forAll(cFaces, i)
{
label faceI = cFaces[i];
if
(
mesh.isInternalFace(faceI)
|| isA<cyclicPolyPatch>(pbm[pbm.whichPatch(faceI)])
)
{
freeAdj++;
}
}
}
// Construct from components
Foam::thoboisValve::thoboisValve
(
const word& name,
const polyMesh& mesh,
const autoPtr<coordinateSystem>& valveCS,
const word& bottomPatchName,
const word& poppetPatchName,
const word& sidePatchName,
const word& stemPatchName,
const word& detachInCylinderPatchName,
const word& detachInPortPatchName,
const word& detachFacesName,
const graph& liftProfile,
const scalar minLift,
const scalar diameter,
const word& staticPointsName,
const word& movingPointsName,
const word& movingInternalPointsName,
const word& staticCellsName,
const word& movingCellsName
)
:
name_(name),
mesh_(mesh),
engineDB_(refCast<const engineTime>(mesh.time())),
csPtr_(valveCS),
bottomPatch_(bottomPatchName, mesh.boundaryMesh()),
poppetPatch_(poppetPatchName, mesh.boundaryMesh()),
sidePatch_(sidePatchName, mesh.boundaryMesh()),
stemPatch_(stemPatchName, mesh.boundaryMesh()),
detachInCylinderPatch_(detachInCylinderPatchName, mesh.boundaryMesh()),
detachInPortPatch_(detachInPortPatchName, mesh.boundaryMesh()),
detachFacesName_(detachFacesName),
liftProfile_(liftProfile),
liftProfileStart_(min(liftProfile_.x())),
liftProfileEnd_(max(liftProfile_.x())),
minLift_(minLift),
diameter_(diameter),
staticPointsName_(staticPointsName),
movingPointsName_(movingPointsName),
movingInternalPointsName_(movingInternalPointsName),
staticCellsName_(staticCellsName),
movingCellsName_(movingCellsName)
{}
// Construct from components
polyGeneralBoundary::polyGeneralBoundary
(
Time& t,
const polyMesh& mesh,
polyMoleculeCloud& molCloud,
const dictionary& dict
)
:
mesh_(refCast<const fvMesh>(mesh)),
molCloud_(molCloud),
boundaryDict_(dict.subDict("generalBoundaryProperties")),
time_(t),
patchName_(boundaryDict_.lookup("patchName")),
patchId_(0),
faces_(),
nFaces_(0),
cells_(),
densities_(),
velocities_(),
temperatures_(),
writeInTimeDir_(true),
writeInCase_(true)
{
//- confirm that the patch exists on the mesh
patchId_ = mesh_.boundaryMesh().findPatchID(patchName_);
if(patchId_ == -1)
{
FatalErrorIn("polyPatchBoundary::polyPatchBoundary()")
<< "Cannot find patch: " << patchName_ << nl << "in: "
<< t.system()/"boundariesDict"
<< exit(FatalError);
}
const polyPatch& patch = mesh.boundaryMesh()[patchId_];
// Pout << "patch name: " << patchName_ << ", patch size: " << patch.size() << endl;
//- initialise data members
faces_.setSize(patch.size());
cells_.setSize(patch.size());
//- loop through all faces and set the boundary cells
//- no conflict with parallelisation because the faces are unique
for(label i = 0; i < patch.size(); i++)
{
label globalFaceI = patch.start() + i;
faces_[i] = globalFaceI;
cells_[i] = patch.faceCells()[i];
}
}
Foam::patchInteractionDataList::patchInteractionDataList
(
const polyMesh& mesh,
const dictionary& dict
)
:
List<patchInteractionData>(dict.lookup("patches")),
patchGroupIDs_(this->size())
{
const polyBoundaryMesh& bMesh = mesh.boundaryMesh();
const wordList allPatchNames = bMesh.names();
const List<patchInteractionData>& items = *this;
forAllReverse(items, i)
{
const word& patchName = items[i].patchName();
labelList patchIDs = findStrings(patchName, allPatchNames);
if (patchIDs.empty())
{
WarningInFunction
<< "Cannot find any patch names matching " << patchName
<< endl;
}
patchGroupIDs_[i].transfer(patchIDs);
}
// Check that all patches are specified
DynamicList<word> badPatches;
forAll(bMesh, patchI)
{
const polyPatch& pp = bMesh[patchI];
if
(
!pp.coupled()
&& !isA<emptyPolyPatch>(pp)
&& !isA<cyclicAMIPolyPatch>(pp)
&& applyToPatch(pp.index()) < 0
)
{
badPatches.append(pp.name());
}
}
if (badPatches.size() > 0)
{
FatalErrorInFunction
<< "All patches must be specified when employing local patch "
<< "interaction. Please specify data for patches:" << nl
<< badPatches << nl << exit(FatalError);
}
}
void Foam::decompositionMethod::calcCellCells
(
const polyMesh& mesh,
const labelList& agglom,
const label nLocalCoarse,
const bool parallel,
CompactListList<label>& cellCells
)
{
const labelList& faceOwner = mesh.faceOwner();
const labelList& faceNeighbour = mesh.faceNeighbour();
const polyBoundaryMesh& patches = mesh.boundaryMesh();
// Create global cell numbers
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
globalIndex globalAgglom
(
nLocalCoarse,
Pstream::msgType(),
Pstream::worldComm,
parallel
);
// Get agglomerate owner on other side of coupled faces
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
labelList globalNeighbour(mesh.nFaces()-mesh.nInternalFaces());
forAll(patches, patchI)
{
const polyPatch& pp = patches[patchI];
if (pp.coupled() && (parallel || !isA<processorPolyPatch>(pp)))
{
label faceI = pp.start();
label bFaceI = pp.start() - mesh.nInternalFaces();
forAll(pp, i)
{
globalNeighbour[bFaceI] = globalAgglom.toGlobal
(
agglom[faceOwner[faceI]]
);
bFaceI++;
faceI++;
}
}
RBFMeshMotionSolver::RBFMeshMotionSolver(
const polyMesh & mesh,
Istream & msData
)
:
motionSolver( mesh ),
motionCenters( mesh.boundaryMesh().size(), vectorField( 0 ) ),
staticPatches( lookup( "staticPatches" ) ),
staticPatchIDs( staticPatches.size() ),
movingPatches( lookup( "movingPatches" ) ),
movingPatchIDs( movingPatches.size() ),
fixedPatches( lookup( "fixedPatches" ) ),
fixedPatchIDs( fixedPatches.size() ),
newPoints( mesh.points().size(), vector::zero ),
rbf( false ),
nbGlobalFaceCenters( Pstream::nProcs(), 0 ),
nbGlobalMovingFaceCenters( Pstream::nProcs(), 0 ),
nbGlobalStaticFaceCenters( Pstream::nProcs(), 0 ),
nbGlobalFixedFaceCenters( Pstream::nProcs(), 0 ),
globalMovingPointsLabelList( mesh.boundaryMesh().size(), labelList( 0 ) ),
twoDCorrector( mesh ),
nbPoints( 0 ),
faceCellCenters( true ),
cpu( false ),
timeIntegrationScheme( false ),
corrector( false ),
k( 0 )
{
// Find IDs of staticPatches
forAll( staticPatches, patchI )
{
label patchIndex = mesh.boundaryMesh().findPatchID( staticPatches[patchI] );
assert( patchIndex >= 0 );
staticPatchIDs[patchI] = patchIndex;
}
Foam::pointMesh::pointMesh(const polyMesh& pMesh)
:
MeshObject<polyMesh, Foam::UpdateableMeshObject, pointMesh>(pMesh),
GeoMesh<polyMesh>(pMesh),
boundary_(*this, pMesh.boundaryMesh())
{
if (debug)
{
Pout<< "pointMesh::pointMesh(const polyMesh&): "
<< "Constructing from polyMesh " << pMesh.name()
<< endl;
}
// Calculate the geometry for the patches (transformation tensors etc.)
boundary_.calcGeometry();
}
// Construct from components
Foam::enginePiston::enginePiston
(
const polyMesh& mesh,
const word& pistonPatchName,
const autoPtr<coordinateSystem>& pistonCS,
const scalar minLayer,
const scalar maxLayer
)
:
mesh_(mesh),
engineDB_(refCast<const engineTime>(mesh.time())),
patchID_(pistonPatchName, mesh.boundaryMesh()),
csPtr_(pistonCS),
minLayer_(minLayer),
maxLayer_(maxLayer)
{}
// Construct from components
Foam::dieselEngineValve::dieselEngineValve
(
const word& name,
const polyMesh& mesh,
const autoPtr<coordinateSystem>& valveCS,
const word& bottomPatchName,
const word& poppetPatchName,
const word& sidePatchName,
const word& stemPatchName,
const word& downInPortPatchName,
const word& downInCylinderPatchName,
const word& upInPortPatchName,
const word& upInCylinderPatchName,
const word& detachInCylinderPatchName,
const word& detachInPortPatchName,
const labelList& detachFaces,
const scalar& detachTol,
const graph& liftProfile,
const scalar minLift,
const scalar diameter
)
:
name_(name),
mesh_(mesh),
engineDB_(refCast<const engineTime>(mesh.time())),
csPtr_(valveCS),
bottomPatch_(bottomPatchName, mesh.boundaryMesh()),
poppetPatch_(poppetPatchName, mesh.boundaryMesh()),
sidePatch_(sidePatchName, mesh.boundaryMesh()),
stemPatch_(stemPatchName, mesh.boundaryMesh()),
downInPortPatch_(downInPortPatchName, mesh.boundaryMesh()),
downInCylinderPatch_(downInCylinderPatchName, mesh.boundaryMesh()),
upInPortPatch_(upInPortPatchName, mesh.boundaryMesh()),
upInCylinderPatch_(upInCylinderPatchName, mesh.boundaryMesh()),
detachInCylinderPatch_(detachInCylinderPatchName, mesh.boundaryMesh()),
detachInPortPatch_(detachInPortPatchName, mesh.boundaryMesh()),
detachFaces_(detachFaces),
detachTol_(detachTol),
liftProfile_(liftProfile),
liftProfileStart_(min(liftProfile_.x())),
liftProfileEnd_(max(liftProfile_.x())),
minLift_(minLift),
diameter_(diameter)
{}
void Foam::syncTools::syncPointMap
(
const polyMesh& mesh,
Map<T>& pointValues, // from mesh point label to value
const CombineOp& cop,
const TransformOp& top
)
{
const polyBoundaryMesh& patches = mesh.boundaryMesh();
// Synchronize multiple shared points.
const globalMeshData& pd = mesh.globalData();
// Values on shared points. Keyed on global shared index.
Map<T> sharedPointValues(0);
if (pd.nGlobalPoints() > 0)
{
// meshPoint per local index
const labelList& sharedPtLabels = pd.sharedPointLabels();
// global shared index per local index
const labelList& sharedPtAddr = pd.sharedPointAddr();
sharedPointValues.resize(sharedPtAddr.size());
// Fill my entries in the shared points
forAll(sharedPtLabels, i)
{
label meshPointi = sharedPtLabels[i];
typename Map<T>::const_iterator fnd =
pointValues.find(meshPointi);
if (fnd != pointValues.end())
{
combine
(
sharedPointValues,
cop,
sharedPtAddr[i], // index
fnd() // value
);
}
}
}
// Construct from dictionary
Foam::engineValve::engineValve
(
const word& name,
const polyMesh& mesh,
const dictionary& dict
)
:
name_(name),
mesh_(mesh),
engineDB_(refCast<const engineTime>(mesh_.time())),
csPtr_
(
coordinateSystem::New
(
"coordinateSystem",
dict.subDict("coordinateSystem")
)
),
bottomPatch_(dict.lookup("bottomPatch"), mesh.boundaryMesh()),
poppetPatch_(dict.lookup("poppetPatch"), mesh.boundaryMesh()),
stemPatch_(dict.lookup("stemPatch"), mesh.boundaryMesh()),
curtainInPortPatch_
(
dict.lookup("curtainInPortPatch"),
mesh.boundaryMesh()
),
curtainInCylinderPatch_
(
dict.lookup("curtainInCylinderPatch"),
mesh.boundaryMesh()
),
detachInCylinderPatch_
(
dict.lookup("detachInCylinderPatch"),
mesh.boundaryMesh()
),
detachInPortPatch_
(
dict.lookup("detachInPortPatch"),
mesh.boundaryMesh()
),
detachFaces_(dict.lookup("detachFaces")),
liftProfile_("theta", "lift", name_, dict.lookup("liftProfile")),
liftProfileStart_(min(liftProfile_.x())),
liftProfileEnd_(max(liftProfile_.x())),
minLift_(readScalar(dict.lookup("minLift"))),
minTopLayer_(readScalar(dict.lookup("minTopLayer"))),
maxTopLayer_(readScalar(dict.lookup("maxTopLayer"))),
minBottomLayer_(readScalar(dict.lookup("minBottomLayer"))),
maxBottomLayer_(readScalar(dict.lookup("maxBottomLayer"))),
diameter_(readScalar(dict.lookup("diameter")))
{}
void writeWeights(const polyMesh& mesh)
{
const polyBoundaryMesh& pbm = mesh.boundaryMesh();
const word tmName(mesh.time().timeName());
forAll(pbm, patchI)
{
if (isA<cyclicAMIPolyPatch>(pbm[patchI]))
{
const cyclicAMIPolyPatch& cpp =
refCast<const cyclicAMIPolyPatch>(pbm[patchI]);
if (cpp.owner())
{
Info<< "Calculating AMI weights between owner patch: "
<< cpp.name() << " and neighbour patch: "
<< cpp.neighbPatch().name() << endl;
const AMIPatchToPatchInterpolation& ami =
cpp.AMI();
writeWeights
(
ami.tgtWeightsSum(),
cpp.neighbPatch(),
"postProcessing",
"tgt",
tmName
);
writeWeights
(
ami.srcWeightsSum(),
cpp,
"postProcessing",
"src",
tmName
);
}
}
}
}