Foam::cellShape Foam::degenerateMatcher::match(const faceList& faces)
{
// Do as if single cell mesh; all faces are referenced by a single cell
return match
(
faces,
labelList(faces.size(), 0), // Cell 0 is owner of all faces
0, // cell 0
labelList(cellMatcher::makeIdentity(faces.size())) // cell 0 consists
// of all faces
);
}
void Foam::vtkSurfaceWriter::writeGeometry
(
Ostream& os,
const pointField& points,
const faceList& faces
)
{
// header
os
<< "# vtk DataFile Version 2.0" << nl
<< "sampleSurface" << nl
<< "ASCII" << nl
<< "DATASET POLYDATA" << nl;
// Write vertex coords
os << "POINTS " << points.size() << " double" << nl;
forAll(points, pointi)
{
const point& pt = points[pointi];
os << float(pt.x()) << ' '
<< float(pt.y()) << ' '
<< float(pt.z()) << nl;
}
os << nl;
// Write faces
label nNodes = 0;
forAll(faces, facei)
{
nNodes += faces[facei].size();
}
os << "POLYGONS " << faces.size() << ' '
<< faces.size() + nNodes << nl;
forAll(faces, facei)
{
const face& f = faces[facei];
os << f.size();
forAll(f, fp)
{
os << ' ' << f[fp];
}
os << nl;
}
}
bool Foam::primitiveMesh::calcPointOrder
(
label& nInternalPoints,
labelList& oldToNew,
const faceList& faces,
const label nInternalFaces,
const label nPoints
)
{
// Internal points are points that are not used by a boundary face.
// Map from old to new position
oldToNew.setSize(nPoints);
oldToNew = -1;
// 1. Create compact addressing for boundary points. Start off by indexing
// from 0 inside oldToNew. (shifted up later on)
label nBoundaryPoints = 0;
for (label faceI = nInternalFaces; faceI < faces.size(); faceI++)
{
const face& f = faces[faceI];
forAll(f, fp)
{
label pointI = f[fp];
if (oldToNew[pointI] == -1)
{
oldToNew[pointI] = nBoundaryPoints++;
}
}
}
void Foam::stl<Type>::write
(
const fileName& samplePath,
const fileName& timeDir,
const fileName& surfaceName,
const pointField& points,
const faceList& faces,
const fileName& fieldName,
const Field<Type>& values,
const bool verbose
) const
{
fileName surfaceDir(samplePath/timeDir);
if (!exists(surfaceDir))
{
mkDir(surfaceDir);
}
fileName planeFName(surfaceDir/fieldName + '_' + surfaceName + ".stl");
if (verbose)
{
Info<< "Writing field " << fieldName << " to " << planeFName << endl;
}
// Convert faces to triangles.
DynamicList<labelledTri> tris(faces.size());
forAll(faces, i)
{
const face& f = faces[i];
faceList triFaces(f.nTriangles(points));
label nTris = 0;
f.triangles(points, nTris, triFaces);
forAll(triFaces, triI)
{
const face& tri = triFaces[triI];
tris.append(labelledTri(tri[0], tri[1], tri[2], 0));
}
}
triSurface
(
tris.shrink(),
geometricSurfacePatchList
(
1,
geometricSurfacePatch
(
"patch", // geometricType
string::validate<word>(fieldName), // fieldName
0 // index
)
),
points
).write(planeFName);
}
void Foam::dxSurfaceWriter<Type>::writeGeometry
(
Ostream& os,
const pointField& points,
const faceList& faces
)
{
// Write vertex coordinates
os << "# The irregular positions" << nl
<< "object 1 class array type float rank 1 shape 3 items "
<< points.size() << " data follows" << nl;
forAll(points, pointI)
{
const point& pt = points[pointI];
os << float(pt.x()) << ' ' << float(pt.y()) << ' ' << float(pt.z())
<< nl;
}
os << nl;
// Write triangles
os << "# The irregular connections (triangles)" << nl
<< "object 2 class array type int rank 1 shape 3 items "
<< faces.size() << " data follows" << nl;
forAll(faces, faceI)
{
const face& f = faces[faceI];
if (f.size() != 3)
{
FatalErrorIn
(
"writeGeometry(Ostream&, const pointField&, const faceList&)"
) << "Face " << faceI << " vertices " << f
<< " is not a triangle."
<< exit(FatalError);
}
os << f[0] << ' ' << f[1] << ' ' << f[2] << nl;
}
os << "attribute \"element type\" string \"triangles\"" << nl
<< "attribute \"ref\" string \"positions\"" << nl << nl;
}
void Foam::foamSurfaceWriter::write
(
const fileName& outputDir,
const fileName& surfaceName,
const pointField& points,
const faceList& faces,
const bool verbose
) const
{
fileName surfaceDir(outputDir/surfaceName);
if (!isDir(surfaceDir))
{
mkDir(surfaceDir);
}
if (verbose)
{
Info<< "Writing geometry to " << surfaceDir << endl;
}
// Points
OFstream(surfaceDir/"points")() << points;
// Faces
OFstream(surfaceDir/"faces")() << faces;
// Face centers. Not really necessary but very handy when reusing as inputs
// for e.g. timeVaryingMapped bc.
pointField faceCentres(faces.size(),point::zero);
forAll(faces, facei)
{
faceCentres[facei] = faces[facei].centre(points);
}
void Foam::CV2D::calcDual
(
point2DField& dualPoints,
faceList& dualFaces,
wordList& patchNames,
labelList& patchSizes,
EdgeMap<label>& mapEdgesRegion,
EdgeMap<label>& indirectPatchEdge
) const
{
// Dual points stored in triangle order.
dualPoints.setSize(number_of_faces());
label dualVerti = 0;
for
(
Triangulation::Finite_faces_iterator fit = finite_faces_begin();
fit != finite_faces_end();
++fit
)
{
if
(
fit->vertex(0)->internalOrBoundaryPoint()
|| fit->vertex(1)->internalOrBoundaryPoint()
|| fit->vertex(2)->internalOrBoundaryPoint()
)
{
fit->faceIndex() = dualVerti;
dualPoints[dualVerti++] = toPoint2D(circumcenter(fit));
}
else
{
fit->faceIndex() = -1;
}
}
dualPoints.setSize(dualVerti);
extractPatches(patchNames, patchSizes, mapEdgesRegion, indirectPatchEdge);
forAll(patchNames, patchi)
{
Info<< "Patch " << patchNames[patchi]
<< " has size " << patchSizes[patchi] << endl;
}
// Create dual faces
// ~~~~~~~~~~~~~~~~~
dualFaces.setSize(number_of_vertices());
label dualFacei = 0;
labelList faceVerts(maxNvert);
for
(
Triangulation::Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
++vit
)
{
if (vit->internalOrBoundaryPoint())
{
Face_circulator fcStart = incident_faces(vit);
Face_circulator fc = fcStart;
label verti = 0;
do
{
if (!is_infinite(fc))
{
if (fc->faceIndex() < 0)
{
FatalErrorInFunction
<< "Dual face uses vertex defined by a triangle"
" defined by an external point"
<< exit(FatalError);
}
// Look up the index of the triangle
faceVerts[verti++] = fc->faceIndex();
}
} while (++fc != fcStart);
if (faceVerts.size() > 2)
{
dualFaces[dualFacei++] =
face(labelList::subList(faceVerts, verti));
}
else
{
Info<< "From triangle point:" << vit->index()
<< " coord:" << toPoint2D(vit->point())
<< " generated illegal dualFace:" << faceVerts
<< endl;
}
}
}
dualFaces.setSize(dualFacei);
}
<< "Negative point label " << blockShape_[pi]
<< " in block " << *this
<< exit(FatalIOError);
}
else if (blockShape_[pi] >= vertices_.size())
{
FatalIOErrorInFunction(is)
<< "Point label " << blockShape_[pi]
<< " out of range 0.." << vertices_.size() - 1
<< " in block " << *this
<< exit(FatalIOError);
}
}
const point blockCentre(blockShape_.centre(vertices_));
const faceList faces(blockShape_.faces());
// Check each face is outward-pointing with respect to the block centre
label outwardFaceCount = 0;
boolList correctFaces(faces.size(), true);
forAll(faces, i)
{
point faceCentre(faces[i].centre(vertices_));
vector faceNormal(faces[i].normal(vertices_));
if (mag(faceNormal) > SMALL)
{
if (((faceCentre - blockCentre) & faceNormal) > 0)
{
outwardFaceCount++;
}
void Foam::ParticleCollector<CloudType>::makeLogFile
(
const faceList& faces,
const Field<point>& points,
const Field<scalar>& area
)
{
// Create the output file if not already created
if (log_)
{
if (debug)
{
Info<< "Creating output file" << endl;
}
if (Pstream::master())
{
// Create directory if does not exist
mkDir(this->writeTimeDir());
// Open new file at start up
outputFilePtr_.reset
(
new OFstream(this->writeTimeDir()/(type() + ".dat"))
);
outputFilePtr_()
<< "# Source : " << type() << nl
<< "# Bins : " << faces.size() << nl
<< "# Total area : " << sum(area) << nl;
outputFilePtr_()
<< "# Geometry :" << nl
<< '#'
<< tab << "Bin"
<< tab << "(Centre_x Centre_y Centre_z)"
<< tab << "Area"
<< nl;
forAll(faces, i)
{
outputFilePtr_()
<< '#'
<< tab << i
<< tab << faces[i].centre(points)
<< tab << area[i]
<< nl;
}
outputFilePtr_()
<< '#' << nl
<< "# Output format:" << nl;
forAll(faces, i)
{
word id = Foam::name(i);
word binId = "bin_" + id;
outputFilePtr_()
<< '#'
<< tab << "Time"
<< tab << binId
<< tab << "mass[" << id << "]"
<< tab << "massFlowRate[" << id << "]"
<< endl;
}
}