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::UnsortedMeshedSurface<Face>::UnsortedMeshedSurface
(
const Xfer<pointField>& pointLst,
const Xfer<List<Face> >& faceLst,
const labelUList& zoneSizes,
const UList<word>& zoneNames
)
:
ParentType(pointLst, faceLst)
{
if (zoneSizes.size())
{
if (zoneNames.size())
{
setZones(zoneSizes, zoneNames);
}
else
{
setZones(zoneSizes);
}
}
else
{
setOneZone();
}
}
void Foam::globalIndex::gather
(
const labelUList& off,
const label comm,
const labelList& procIDs,
const UList<Type>& fld,
List<Type>& allFld,
const int tag,
const Pstream::commsTypes commsType
)
{
if (Pstream::myProcNo(comm) == procIDs[0])
{
allFld.setSize(off.last());
// Assign my local data
SubList<Type>(allFld, fld.size(), 0) = fld;
if
(
commsType == Pstream::commsTypes::scheduled
|| commsType == Pstream::commsTypes::blocking
)
{
for (label i = 1; i < procIDs.size(); i++)
{
SubList<Type> procSlot(allFld, off[i+1]-off[i], off[i]);
if (contiguous<Type>())
{
IPstream::read
(
commsType,
procIDs[i],
reinterpret_cast<char*>(procSlot.begin()),
procSlot.byteSize(),
tag,
comm
);
}
else
{
IPstream fromSlave
(
commsType,
procIDs[i],
0,
tag,
comm
);
fromSlave >> procSlot;
}
}
}
else
{
// nonBlocking
if (!contiguous<Type>())
void Foam::cuttingPlane::calcCutCells
(
const primitiveMesh& mesh,
const scalarField& dotProducts,
const labelUList& cellIdLabels
)
{
const labelListList& cellEdges = mesh.cellEdges();
const edgeList& edges = mesh.edges();
label listSize = cellEdges.size();
if (notNull(cellIdLabels))
{
listSize = cellIdLabels.size();
}
cutCells_.setSize(listSize);
label cutcellI(0);
// Find the cut cells by detecting any cell that uses points with
// opposing dotProducts.
for (label listI = 0; listI < listSize; ++listI)
{
label cellI = listI;
if (notNull(cellIdLabels))
{
cellI = cellIdLabels[listI];
}
const labelList& cEdges = cellEdges[cellI];
label nCutEdges = 0;
forAll(cEdges, i)
{
const edge& e = edges[cEdges[i]];
if
(
(dotProducts[e[0]] < zeroish && dotProducts[e[1]] > positive)
|| (dotProducts[e[1]] < zeroish && dotProducts[e[0]] > positive)
)
{
nCutEdges++;
if (nCutEdges > 2)
{
cutCells_[cutcellI++] = cellI;
break;
}
}
}
}
// Set correct list size
cutCells_.setSize(cutcellI);
}
Foam::Field<Type>::Field
(
const tmp<Field<Type>>& tmapF,
const labelUList& mapAddressing
)
:
List<Type>(mapAddressing.size())
{
map(tmapF, mapAddressing);
}
Foam::boundBox::boundBox
(
const UList<point>& points,
const labelUList& indices,
const bool doReduce
)
:
min_(Zero),
max_(Zero)
{
if (points.empty() || indices.empty())
{
if (doReduce && Pstream::parRun())
{
// Use values that get overwritten by reduce minOp, maxOp below
min_ = point(VGREAT, VGREAT, VGREAT);
max_ = point(-VGREAT, -VGREAT, -VGREAT);
}
}
else
{
min_ = points[indices[0]];
max_ = points[indices[0]];
for (label i=1; i < indices.size(); ++i)
{
min_ = ::Foam::min(min_, points[indices[i]]);
max_ = ::Foam::max(max_, points[indices[i]]);
}
}
// Reduce parallel information
if (doReduce)
{
reduce(min_, minOp<point>());
reduce(max_, maxOp<point>());
}
}
Foam::tmp<Foam::labelField> Foam::regionCoupledFvPatch::internalFieldTransfer
(
const Pstream::commsTypes commsType,
const labelUList& iF
) const
{
if (neighbFvPatch().sameRegion())
{
return neighbFvPatch().patchInternalField(iF);
}
else
{
return tmp<labelField>(new labelField(iF.size(), 0));
}
return tmp<labelField>(nullptr);
}
void Foam::UnsortedMeshedSurface<Face>::setZones
(
const labelUList& sizes,
const UList<word>& names
)
{
zoneIds_.setSize(size());
zoneToc_.setSize(sizes.size());
label start = 0;
forAll(zoneToc_, zoneI)
{
zoneToc_[zoneI] = surfZoneIdentifier(names[zoneI], zoneI);
// assign sub-zone Ids
SubList<label> subZone(zoneIds_, sizes[zoneI], start);
subZone = zoneI;
start += sizes[zoneI];
}