Foam::polyPatch::polyPatch
(
const word& name,
const label size,
const label start,
const label index,
const polyBoundaryMesh& bm,
const word& patchType
)
:
patchIdentifier(name, index),
primitivePatch
(
faceSubList(bm.mesh().faces(), size, start),
bm.mesh().points()
),
start_(start),
boundaryMesh_(bm),
faceCellsPtr_(NULL),
gpuFaceCells(),
mePtr_(NULL)
{
if
(
patchType != word::null
&& constraintType(patchType)
&& findIndex(inGroups(), patchType) == -1
)
{
inGroups().append(patchType);
}
}
Foam::polyPatch::polyPatch
(
const word& name,
const dictionary& dict,
const label index,
const polyBoundaryMesh& bm,
const word& patchType
)
:
patchIdentifier(name, dict, index),
primitivePatch
(
faceSubList
(
bm.mesh().faces(),
readLabel(dict.lookup("nFaces")),
readLabel(dict.lookup("startFace"))
),
bm.mesh().points()
),
start_(readLabel(dict.lookup("startFace"))),
boundaryMesh_(bm),
faceCellsPtr_(NULL),
mePtr_(NULL)
{
if
(
patchType != word::null
&& constraintType(patchType)
&& findIndex(inGroups(), patchType) == -1
)
{
inGroups().append(patchType);
}
}
Foam::polyPatch::polyPatch
(
const polyPatch& pp,
const polyBoundaryMesh& bm,
const label index,
const labelUList& mapAddressing,
const label newStart
)
:
patchIdentifier(pp, index),
primitivePatch
(
faceSubList
(
bm.mesh().faces(),
mapAddressing.size(),
newStart
),
bm.mesh().points()
),
start_(newStart),
boundaryMesh_(bm),
faceCellsPtr_(NULL),
gpuFaceCells(),
mePtr_(NULL)
{}
Foam::immersedBoundaryPolyPatch::immersedBoundaryPolyPatch
(
const word& name,
const label size,
const label start,
const label index,
const polyBoundaryMesh& bm
)
:
polyPatch(name, size, start, index, bm),
ibMesh_
(
IOobject
(
name + ".ftr",
bm.mesh().time().constant(), // instance
"triSurface", // local
bm.mesh(), // registry
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
internalFlow_(false),
triSurfSearchPtr_(NULL)
{}
Foam::immersedBoundaryPolyPatch::immersedBoundaryPolyPatch
(
const immersedBoundaryPolyPatch& pp,
const polyBoundaryMesh& bm,
const label index,
const label newSize,
const label newStart
)
:
polyPatch(pp, bm, index, newSize, newStart),
ibMesh_
(
IOobject
(
pp.name() + ".ftr",
bm.mesh().time().constant(), // instance
"triSurface", // local
bm.mesh(), // registry
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
internalFlow_(pp.internalFlow()),
triSurfSearchPtr_(NULL)
{}
label findPatchID(const polyBoundaryMesh& patches, const word& name)
{
const label patchID = patches.findPatchID(name);
if (patchID == -1)
{
FatalErrorInFunction
<< "Cannot find patch " << name
<< " in the source mesh.\n"
<< "Valid patch names are " << patches.names()
<< exit(FatalError);
}
return patchID;
}
Foam::immersedBoundaryPolyPatch::immersedBoundaryPolyPatch
(
const word& name,
const dictionary& dict,
const label index,
const polyBoundaryMesh& bm
)
:
polyPatch(name, dict, index, bm),
ibMesh_
(
IOobject
(
name + ".ftr",
bm.mesh().time().constant(), // instance
"triSurface", // local
bm.mesh(), // registry
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
internalFlow_(dict.lookup("internalFlow")),
triSurfSearchPtr_(NULL)
{
if (size() > 0)
{
FatalIOErrorIn
(
"immersedBoundaryPolyPatch::immersedBoundaryPolyPatch\n"
"(\n"
" const word& name,\n"
" const dictionary& dict,\n"
" const label index,\n"
" const polyBoundaryMesh& bm\n"
")",
dict
) << "Faces detected in the immersedBoundaryPolyPatch. "
<< "This is not allowed: please make sure that the patch size "
<< "equals zero."
<< abort(FatalIOError);
}
}
void Foam::fvBoundaryMesh::addPatches(const polyBoundaryMesh& basicBdry)
{
setSize(basicBdry.size());
// Set boundary patches
fvPatchList& Patches = *this;
forAll(Patches, patchi)
{
Patches.set(patchi, fvPatch::New(basicBdry[patchi], *this));
}
// Checks whether patch present
void checkPatch(const polyBoundaryMesh& bMesh, const word& name)
{
label patchI = bMesh.findPatchID(name);
if (patchI == -1)
{
FatalErrorIn("checkPatch(const polyBoundaryMesh&, const word&)")
<< "Cannot find patch " << name << endl
<< "It should be present and of non-zero size" << endl
<< "Valid patches are " << bMesh.names()
<< exit(FatalError);
}
if (bMesh[patchI].empty())
{
FatalErrorIn("checkPatch(const polyBoundaryMesh&, const word&)")
<< "Patch " << name << " is present but zero size"
<< exit(FatalError);
}
}
Foam::polyPatch::polyPatch
(
const word& name,
const label size,
const label start,
const label index,
const polyBoundaryMesh& bm
)
:
patchIdentifier(name, index),
primitivePatch
(
faceSubList(bm.mesh().faces(), size, start),
bm.mesh().points()
),
start_(start),
boundaryMesh_(bm),
faceCellsPtr_(NULL),
mePtr_(NULL)
{}
Foam::polyPatch::polyPatch
(
const polyPatch& pp,
const polyBoundaryMesh& bm
)
:
patchIdentifier(pp),
primitivePatch
(
faceSubList
(
bm.mesh().faces(),
pp.size(),
pp.start()
),
bm.mesh().points()
),
start_(pp.start()),
boundaryMesh_(bm),
faceCellsPtr_(NULL),
mePtr_(NULL)
{}
Foam::polyPatch::polyPatch
(
const word& name,
const dictionary& dict,
const label index,
const polyBoundaryMesh& bm
)
:
patchIdentifier(name, dict, index),
primitivePatch
(
faceSubList
(
bm.mesh().faces(),
readLabel(dict.lookup("nFaces")),
readLabel(dict.lookup("startFace"))
),
bm.mesh().points()
),
start_(readLabel(dict.lookup("startFace"))),
boundaryMesh_(bm),
faceCellsPtr_(NULL),
mePtr_(NULL)
{}
Foam::pointBoundaryMesh::pointBoundaryMesh
(
const pointMesh& m,
const polyBoundaryMesh& basicBdry
)
:
pointPatchList(basicBdry.size()),
mesh_(m)
{
// Set boundary patches
pointPatchList& Patches = *this;
forAll(Patches, patchI)
{
Patches.set
(
patchI,
facePointPatch::New(basicBdry[patchI], *this).ptr()
);
}
triSurface triangulate
(
const polyBoundaryMesh& bMesh,
const labelHashSet& includePatches,
const labelListIOList& finalAgglom,
labelList& triSurfaceToAgglom,
const globalIndex& globalNumbering,
const polyBoundaryMesh& coarsePatches
)
{
const polyMesh& mesh = bMesh.mesh();
// Storage for surfaceMesh. Size estimate.
DynamicList<labelledTri> triangles
(
mesh.nFaces() - mesh.nInternalFaces()
);
label newPatchI = 0;
label localTriFaceI = 0;
forAllConstIter(labelHashSet, includePatches, iter)
{
const label patchI = iter.key();
const polyPatch& patch = bMesh[patchI];
const pointField& points = patch.points();
label nTriTotal = 0;
forAll(patch, patchFaceI)
{
const face& f = patch[patchFaceI];
faceList triFaces(f.nTriangles(points));
label nTri = 0;
f.triangles(points, nTri, triFaces);
forAll(triFaces, triFaceI)
{
const face& f = triFaces[triFaceI];
triangles.append(labelledTri(f[0], f[1], f[2], newPatchI));
nTriTotal++;
triSurfaceToAgglom[localTriFaceI++] = globalNumbering.toGlobal
(
Pstream::myProcNo(),
finalAgglom[patchI][patchFaceI]
+ coarsePatches[patchI].start()
);
}
}
newPatchI++;
}
triSurfaceToAgglom.resize(localTriFaceI-1);
triangles.shrink();
// Create globally numbered tri surface
triSurface rawSurface(triangles, mesh.points());
// Create locally numbered tri surface
triSurface surface
(
rawSurface.localFaces(),
rawSurface.localPoints()
);
// Add patch names to surface
surface.patches().setSize(newPatchI);
newPatchI = 0;
forAllConstIter(labelHashSet, includePatches, iter)
{
const label patchI = iter.key();
const polyPatch& patch = bMesh[patchI];
surface.patches()[newPatchI].index() = patchI;
surface.patches()[newPatchI].name() = patch.name();
surface.patches()[newPatchI].geometricType() = patch.type();
newPatchI++;
}
return surface;
}
