mirror of
https://develop.openfoam.com/Development/openfoam.git
synced 2025-11-28 03:28:01 +00:00
Creation of OpenFOAM-dev repository 15/04/2008
This commit is contained in:
OpenFOAM-admin
@ -0,0 +1,932 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 1991-2007 OpenCFD Ltd.
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
This file is part of OpenFOAM.
|
||||
|
||||
OpenFOAM is free software; you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by the
|
||||
Free Software Foundation; either version 2 of the License, or (at your
|
||||
option) any later version.
|
||||
|
||||
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OpenFOAM; if not, write to the Free Software Foundation,
|
||||
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "argList.H"
|
||||
#include "Time.H"
|
||||
#include "ensightMesh.H"
|
||||
#include "fvMesh.H"
|
||||
#include "PstreamCombineReduceOps.H"
|
||||
#include "processorPolyPatch.H"
|
||||
#include "cellModeller.H"
|
||||
#include "IOmanip.H"
|
||||
#include "itoa.H"
|
||||
|
||||
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
class concatPatchNames
|
||||
{
|
||||
|
||||
public:
|
||||
|
||||
void operator()
|
||||
(
|
||||
HashTable<labelList>& x,
|
||||
const HashTable<labelList>& y
|
||||
) const
|
||||
{
|
||||
for
|
||||
(
|
||||
HashTable<labelList>::const_iterator iter = y.begin();
|
||||
iter != y.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
HashTable<labelList>::iterator xiter = x.find(iter.key());
|
||||
|
||||
if (xiter == x.end())
|
||||
{
|
||||
x.insert(iter.key(), iter());
|
||||
}
|
||||
else
|
||||
{
|
||||
labelList& xPatches = xiter();
|
||||
const labelList& yPatches = iter();
|
||||
|
||||
label offset = xPatches.size();
|
||||
xPatches.setSize(offset + yPatches.size());
|
||||
|
||||
forAll(yPatches, i)
|
||||
{
|
||||
xPatches[i + offset] = yPatches[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
|
||||
|
||||
// Construct from fvMesh
|
||||
Foam::ensightMesh::ensightMesh(const fvMesh& fMesh, const argList& args)
|
||||
:
|
||||
mesh(fMesh),
|
||||
meshCellSets(mesh.nCells()),
|
||||
boundaryFaceSets(mesh.boundary().size())
|
||||
{
|
||||
forAll (mesh.boundaryMesh(), patchi)
|
||||
{
|
||||
if (typeid(mesh.boundaryMesh()[patchi]) != typeid(processorPolyPatch))
|
||||
{
|
||||
if (!allPatchNames.found(mesh.boundaryMesh()[patchi].name()))
|
||||
{
|
||||
allPatchNames.insert
|
||||
(
|
||||
mesh.boundaryMesh()[patchi].name(),
|
||||
labelList(1, Pstream::myProcNo())
|
||||
);
|
||||
|
||||
patchIndices.insert
|
||||
(
|
||||
mesh.boundaryMesh()[patchi].name(),
|
||||
patchi
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
combineReduce(allPatchNames, concatPatchNames());
|
||||
|
||||
if (args.options().found("patches"))
|
||||
{
|
||||
wordList patchNameList(IStringStream(args.options()["patches"])());
|
||||
|
||||
if (!patchNameList.size())
|
||||
{
|
||||
patchNameList = allPatchNames.toc();
|
||||
}
|
||||
|
||||
forAll (patchNameList, i)
|
||||
{
|
||||
patchNames.insert(patchNameList[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
const cellShapeList& cellShapes = mesh.cellShapes();
|
||||
|
||||
const cellModel& tet = *(cellModeller::lookup("tet"));
|
||||
const cellModel& pyr = *(cellModeller::lookup("pyr"));
|
||||
const cellModel& prism = *(cellModeller::lookup("prism"));
|
||||
const cellModel& wedge = *(cellModeller::lookup("wedge"));
|
||||
const cellModel& hex = *(cellModeller::lookup("hex"));
|
||||
|
||||
labelList& tets = meshCellSets.tets;
|
||||
labelList& pyrs = meshCellSets.pyrs;
|
||||
labelList& prisms = meshCellSets.prisms;
|
||||
labelList& wedges = meshCellSets.wedges;
|
||||
labelList& hexes = meshCellSets.hexes;
|
||||
labelList& polys = meshCellSets.polys;
|
||||
|
||||
// Count the shapes
|
||||
label nTets = 0;
|
||||
label nPyrs = 0;
|
||||
label nPrisms = 0;
|
||||
label nWedges = 0;
|
||||
label nHexes = 0;
|
||||
label nPolys = 0;
|
||||
|
||||
if (!patchNames.size())
|
||||
{
|
||||
forAll(cellShapes, celli)
|
||||
{
|
||||
const cellShape& cellShape = cellShapes[celli];
|
||||
const cellModel& cellModel = cellShape.model();
|
||||
|
||||
if (cellModel == tet)
|
||||
{
|
||||
tets[nTets++] = celli;
|
||||
}
|
||||
else if (cellModel == pyr)
|
||||
{
|
||||
pyrs[nPyrs++] = celli;
|
||||
}
|
||||
else if (cellModel == prism)
|
||||
{
|
||||
prisms[nPrisms++] = celli;
|
||||
}
|
||||
else if (cellModel == wedge)
|
||||
{
|
||||
wedges[nWedges++] = celli;
|
||||
}
|
||||
else if (cellModel == hex)
|
||||
{
|
||||
hexes[nHexes++] = celli;
|
||||
}
|
||||
else
|
||||
{
|
||||
polys[nPolys++] = celli;
|
||||
}
|
||||
}
|
||||
|
||||
tets.setSize(nTets);
|
||||
pyrs.setSize(nPyrs);
|
||||
prisms.setSize(nPrisms);
|
||||
wedges.setSize(nWedges);
|
||||
hexes.setSize(nHexes);
|
||||
polys.setSize(nPolys);
|
||||
|
||||
meshCellSets.nTets = nTets;
|
||||
reduce(meshCellSets.nTets, sumOp<label>());
|
||||
|
||||
meshCellSets.nPyrs = nPyrs;
|
||||
reduce(meshCellSets.nPyrs, sumOp<label>());
|
||||
|
||||
meshCellSets.nPrisms = nPrisms;
|
||||
reduce(meshCellSets.nPrisms, sumOp<label>());
|
||||
|
||||
meshCellSets.nHexesWedges = nHexes + nWedges;
|
||||
reduce(meshCellSets.nHexesWedges, sumOp<label>());
|
||||
|
||||
meshCellSets.nPolys = nPolys;
|
||||
reduce(meshCellSets.nPolys, sumOp<label>());
|
||||
}
|
||||
|
||||
|
||||
forAll (mesh.boundary(), patchi)
|
||||
{
|
||||
if (mesh.boundary()[patchi].size())
|
||||
{
|
||||
const polyPatch& p = mesh.boundaryMesh()[patchi];
|
||||
|
||||
labelList& tris = boundaryFaceSets[patchi].tris;
|
||||
labelList& quads = boundaryFaceSets[patchi].quads;
|
||||
labelList& polys = boundaryFaceSets[patchi].polys;
|
||||
|
||||
tris.setSize(p.size());
|
||||
quads.setSize(p.size());
|
||||
polys.setSize(p.size());
|
||||
|
||||
label nTris = 0;
|
||||
label nQuads = 0;
|
||||
label nPolys = 0;
|
||||
|
||||
forAll(p, facei)
|
||||
{
|
||||
const face& f = p[facei];
|
||||
|
||||
if (f.size() == 3)
|
||||
{
|
||||
tris[nTris++] = facei;
|
||||
}
|
||||
else if (f.size() == 4)
|
||||
{
|
||||
quads[nQuads++] = facei;
|
||||
}
|
||||
else
|
||||
{
|
||||
polys[nPolys++] = facei;
|
||||
}
|
||||
}
|
||||
|
||||
tris.setSize(nTris);
|
||||
quads.setSize(nQuads);
|
||||
polys.setSize(nPolys);
|
||||
}
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashTable<labelList>::const_iterator iter = allPatchNames.begin();
|
||||
iter != allPatchNames.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
const word& patchName = iter.key();
|
||||
nFacePrims nfp;
|
||||
|
||||
if (!patchNames.size() || patchNames.found(patchName))
|
||||
{
|
||||
if (patchIndices.found(patchName))
|
||||
{
|
||||
label patchi = patchIndices.find(patchName)();
|
||||
|
||||
nfp.nPoints = mesh.boundaryMesh()[patchi].localPoints().size();
|
||||
nfp.nTris = boundaryFaceSets[patchi].tris.size();
|
||||
nfp.nQuads = boundaryFaceSets[patchi].quads.size();
|
||||
nfp.nPolys = boundaryFaceSets[patchi].polys.size();
|
||||
}
|
||||
}
|
||||
|
||||
reduce(nfp.nPoints, sumOp<label>());
|
||||
reduce(nfp.nTris, sumOp<label>());
|
||||
reduce(nfp.nQuads, sumOp<label>());
|
||||
reduce(nfp.nPolys, sumOp<label>());
|
||||
|
||||
nPatchPrims.insert(patchName, nfp);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
|
||||
|
||||
Foam::ensightMesh::~ensightMesh()
|
||||
{}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
void Foam::ensightMesh::writePoints
|
||||
(
|
||||
const scalarField& pointsComponent,
|
||||
OFstream& ensightGeometryFile
|
||||
) const
|
||||
{
|
||||
forAll(pointsComponent, pointi)
|
||||
{
|
||||
ensightGeometryFile << setw(12) << float(pointsComponent[pointi]) << nl;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Foam::cellShapeList Foam::ensightMesh::map
|
||||
(
|
||||
const cellShapeList& cellShapes,
|
||||
const labelList& prims
|
||||
) const
|
||||
{
|
||||
cellShapeList mcsl(prims.size());
|
||||
|
||||
forAll(prims, i)
|
||||
{
|
||||
mcsl[i] = cellShapes[prims[i]];
|
||||
}
|
||||
|
||||
return mcsl;
|
||||
}
|
||||
|
||||
|
||||
Foam::cellShapeList Foam::ensightMesh::map
|
||||
(
|
||||
const cellShapeList& cellShapes,
|
||||
const labelList& hexes,
|
||||
const labelList& wedges
|
||||
) const
|
||||
{
|
||||
cellShapeList mcsl(hexes.size() + wedges.size());
|
||||
|
||||
forAll(hexes, i)
|
||||
{
|
||||
mcsl[i] = cellShapes[hexes[i]];
|
||||
}
|
||||
|
||||
label offset = hexes.size();
|
||||
|
||||
const cellModel& hex = *(cellModeller::lookup("hex"));
|
||||
labelList hexLabels(8);
|
||||
|
||||
forAll(wedges, i)
|
||||
{
|
||||
const cellShape& cellPoints = cellShapes[wedges[i]];
|
||||
|
||||
hexLabels[0] = cellPoints[0];
|
||||
hexLabels[1] = cellPoints[1];
|
||||
hexLabels[2] = cellPoints[0];
|
||||
hexLabels[3] = cellPoints[2];
|
||||
hexLabels[4] = cellPoints[3];
|
||||
hexLabels[5] = cellPoints[4];
|
||||
hexLabels[6] = cellPoints[6];
|
||||
hexLabels[7] = cellPoints[5];
|
||||
|
||||
mcsl[i + offset] = cellShape(hex, hexLabels);
|
||||
}
|
||||
|
||||
return mcsl;
|
||||
}
|
||||
|
||||
|
||||
void Foam::ensightMesh::writePrims
|
||||
(
|
||||
const cellShapeList& cellShapes,
|
||||
const label pointOffset,
|
||||
OFstream& ensightGeometryFile
|
||||
) const
|
||||
{
|
||||
label po = pointOffset + 1;
|
||||
|
||||
forAll(cellShapes, i)
|
||||
{
|
||||
const cellShape& cellPoints = cellShapes[i];
|
||||
|
||||
forAll(cellPoints, pointi)
|
||||
{
|
||||
ensightGeometryFile<< setw(10) << cellPoints[pointi] + po;
|
||||
}
|
||||
ensightGeometryFile << nl;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Foam::ensightMesh::writePolys
|
||||
(
|
||||
const labelList& polys,
|
||||
const cellList& cellFaces,
|
||||
const faceList& faces,
|
||||
const label pointOffset,
|
||||
OFstream& ensightGeometryFile
|
||||
) const
|
||||
{
|
||||
if (polys.size())
|
||||
{
|
||||
ensightGeometryFile
|
||||
<< "nfaced" << nl << setw(10) << polys.size() << nl;
|
||||
|
||||
label po = pointOffset + 1;
|
||||
|
||||
forAll(polys, i)
|
||||
{
|
||||
ensightGeometryFile
|
||||
<< setw(10) << cellFaces[polys[i]].size() << nl;
|
||||
}
|
||||
|
||||
forAll(polys, i)
|
||||
{
|
||||
const labelList& cf = cellFaces[polys[i]];
|
||||
|
||||
forAll(cf, facei)
|
||||
{
|
||||
ensightGeometryFile
|
||||
<< setw(10) << faces[cf[facei]].size() << nl;
|
||||
}
|
||||
}
|
||||
|
||||
forAll(polys, i)
|
||||
{
|
||||
const labelList& cf = cellFaces[polys[i]];
|
||||
|
||||
forAll(cf, facei)
|
||||
{
|
||||
const face& f = faces[cf[facei]];
|
||||
|
||||
forAll(f, pointi)
|
||||
{
|
||||
ensightGeometryFile << setw(10) << f[pointi] + po;
|
||||
}
|
||||
ensightGeometryFile << nl;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Foam::ensightMesh::writeAllPrims
|
||||
(
|
||||
const char* key,
|
||||
const label nPrims,
|
||||
const cellShapeList& cellShapes,
|
||||
const labelList& pointOffsets,
|
||||
OFstream& ensightGeometryFile
|
||||
) const
|
||||
{
|
||||
if (nPrims)
|
||||
{
|
||||
if (Pstream::master())
|
||||
{
|
||||
ensightGeometryFile << key << nl << setw(10) << nPrims << nl;
|
||||
|
||||
writePrims(cellShapes, 0, ensightGeometryFile);
|
||||
|
||||
for (int slave=1; slave<Pstream::nProcs(); slave++)
|
||||
{
|
||||
IPstream fromSlave(Pstream::scheduled, slave);
|
||||
cellShapeList cellShapes(fromSlave);
|
||||
|
||||
writePrims
|
||||
(
|
||||
cellShapes,
|
||||
pointOffsets[slave-1],
|
||||
ensightGeometryFile
|
||||
);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
|
||||
toMaster<< cellShapes;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Foam::ensightMesh::writeFacePrims
|
||||
(
|
||||
const char* key,
|
||||
const faceList& patchFaces,
|
||||
const label pointOffset,
|
||||
OFstream& ensightGeometryFile
|
||||
) const
|
||||
{
|
||||
if (patchFaces.size())
|
||||
{
|
||||
if (word(key) == "nsided")
|
||||
{
|
||||
ensightGeometryFile
|
||||
<< key << nl << setw(10) << patchFaces.size() << nl;
|
||||
|
||||
forAll(patchFaces, i)
|
||||
{
|
||||
ensightGeometryFile
|
||||
<< setw(10) << patchFaces[i].size() << nl;
|
||||
}
|
||||
}
|
||||
|
||||
label po = pointOffset + 1;
|
||||
|
||||
forAll(patchFaces, i)
|
||||
{
|
||||
const face& patchFace = patchFaces[i];
|
||||
|
||||
forAll(patchFace, pointi)
|
||||
{
|
||||
ensightGeometryFile << setw(10) << patchFace[pointi] + po;
|
||||
}
|
||||
ensightGeometryFile << nl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Foam::faceList Foam::ensightMesh::map
|
||||
(
|
||||
const faceList& patchFaces,
|
||||
const labelList& prims
|
||||
) const
|
||||
{
|
||||
faceList ppf(prims.size());
|
||||
|
||||
forAll (prims, i)
|
||||
{
|
||||
ppf[i] = patchFaces[prims[i]];
|
||||
}
|
||||
|
||||
return ppf;
|
||||
}
|
||||
|
||||
|
||||
void Foam::ensightMesh::writeAllFacePrims
|
||||
(
|
||||
const char* key,
|
||||
const labelList& prims,
|
||||
const label nPrims,
|
||||
const faceList& patchFaces,
|
||||
const labelList& pointOffsets,
|
||||
const labelList& patchProcessors,
|
||||
OFstream& ensightGeometryFile
|
||||
) const
|
||||
{
|
||||
if (nPrims)
|
||||
{
|
||||
if (Pstream::master())
|
||||
{
|
||||
if (word(key) != "nsided")
|
||||
{
|
||||
ensightGeometryFile << key << nl << setw(10) << nPrims << nl;
|
||||
}
|
||||
|
||||
if (&prims != NULL)
|
||||
{
|
||||
writeFacePrims
|
||||
(
|
||||
key,
|
||||
map(patchFaces, prims),
|
||||
0,
|
||||
ensightGeometryFile
|
||||
);
|
||||
}
|
||||
|
||||
forAll (patchProcessors, i)
|
||||
{
|
||||
if (patchProcessors[i] != 0)
|
||||
{
|
||||
label slave = patchProcessors[i];
|
||||
IPstream fromSlave(Pstream::scheduled, slave);
|
||||
faceList patchFaces(fromSlave);
|
||||
|
||||
writeFacePrims
|
||||
(
|
||||
key,
|
||||
patchFaces,
|
||||
pointOffsets[i],
|
||||
ensightGeometryFile
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (&prims != NULL)
|
||||
{
|
||||
OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
|
||||
toMaster<< map(patchFaces, prims);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Foam::ensightMesh::write
|
||||
(
|
||||
const fileName& postProcPath,
|
||||
const word& prepend,
|
||||
const label timeIndex,
|
||||
Ostream& ensightCaseFile
|
||||
) const
|
||||
{
|
||||
const Time& runTime = mesh.time();
|
||||
const pointField& points = mesh.points();
|
||||
const cellList& cellFaces = mesh.cells();
|
||||
const faceList& faces = mesh.faces();
|
||||
const cellShapeList& cellShapes = mesh.cellShapes();
|
||||
|
||||
word timeFile = prepend;
|
||||
|
||||
if (timeIndex == 0)
|
||||
{
|
||||
timeFile += "000.";
|
||||
}
|
||||
else if (mesh.moving())
|
||||
{
|
||||
timeFile += itoa(timeIndex) + '.';
|
||||
}
|
||||
|
||||
// set the filename of the ensight file
|
||||
fileName ensightGeometryFileName = timeFile + "mesh";
|
||||
|
||||
OFstream *ensightGeometryFilePtr = NULL;
|
||||
if (Pstream::master())
|
||||
{
|
||||
ensightGeometryFilePtr = new OFstream
|
||||
(
|
||||
postProcPath/ensightGeometryFileName,
|
||||
runTime.writeFormat(),
|
||||
runTime.writeVersion(),
|
||||
runTime.writeCompression()
|
||||
);
|
||||
}
|
||||
|
||||
OFstream& ensightGeometryFile = *ensightGeometryFilePtr;
|
||||
|
||||
if (Pstream::master())
|
||||
{
|
||||
// Set Format
|
||||
ensightGeometryFile.setf
|
||||
(
|
||||
ios_base::scientific,
|
||||
ios_base::floatfield
|
||||
);
|
||||
ensightGeometryFile.precision(5);
|
||||
|
||||
ensightGeometryFile
|
||||
<< "OpenFOAM Geometry File " << nl
|
||||
<< "EnSight 8.2.6" << nl
|
||||
<< "node id assign" << nl
|
||||
<< "element id assign" << nl;
|
||||
}
|
||||
|
||||
labelList pointOffsets(Pstream::nProcs(), 0);
|
||||
|
||||
if (!patchNames.size())
|
||||
{
|
||||
label nPoints = points.size();
|
||||
Pstream::gather(nPoints, sumOp<label>());
|
||||
|
||||
if (Pstream::master())
|
||||
{
|
||||
ensightGeometryFile
|
||||
<< "part" << nl
|
||||
<< setw(10) << 1 << nl
|
||||
<< "FOAM cells" << nl
|
||||
<< "coordinates" << nl
|
||||
<< setw(10) << nPoints
|
||||
<< endl;
|
||||
|
||||
for (direction d=0; d<vector::nComponents; d++)
|
||||
{
|
||||
writePoints(points.component(d), ensightGeometryFile);
|
||||
pointOffsets[0] = points.size();
|
||||
|
||||
for (int slave=1; slave<Pstream::nProcs(); slave++)
|
||||
{
|
||||
IPstream fromSlave(Pstream::scheduled, slave);
|
||||
scalarField pointsComponent(fromSlave);
|
||||
writePoints(pointsComponent, ensightGeometryFile);
|
||||
pointOffsets[slave] =
|
||||
pointOffsets[slave-1]
|
||||
+ pointsComponent.size();
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (direction d=0; d<vector::nComponents; d++)
|
||||
{
|
||||
OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
|
||||
toMaster<< points.component(d);
|
||||
}
|
||||
}
|
||||
|
||||
writeAllPrims
|
||||
(
|
||||
"hexa8",
|
||||
meshCellSets.nHexesWedges,
|
||||
map(cellShapes, meshCellSets.hexes, meshCellSets.wedges),
|
||||
pointOffsets,
|
||||
ensightGeometryFile
|
||||
);
|
||||
|
||||
writeAllPrims
|
||||
(
|
||||
"penta6",
|
||||
meshCellSets.nPrisms,
|
||||
map(cellShapes, meshCellSets.prisms),
|
||||
pointOffsets,
|
||||
ensightGeometryFile
|
||||
);
|
||||
|
||||
writeAllPrims
|
||||
(
|
||||
"pyramid5",
|
||||
meshCellSets.nPyrs,
|
||||
map(cellShapes, meshCellSets.pyrs),
|
||||
pointOffsets,
|
||||
ensightGeometryFile
|
||||
);
|
||||
|
||||
writeAllPrims
|
||||
(
|
||||
"tetra4",
|
||||
meshCellSets.nTets,
|
||||
map(cellShapes, meshCellSets.tets),
|
||||
pointOffsets,
|
||||
ensightGeometryFile
|
||||
);
|
||||
|
||||
|
||||
if (meshCellSets.nPolys)
|
||||
{
|
||||
if (Pstream::master())
|
||||
{
|
||||
/*
|
||||
ensightGeometryFile
|
||||
<< "nfaced" << nl
|
||||
<< setw(10) << meshCellSets.nPolys << nl;
|
||||
*/
|
||||
writePolys
|
||||
(
|
||||
meshCellSets.polys,
|
||||
cellFaces,
|
||||
faces,
|
||||
0,
|
||||
ensightGeometryFile
|
||||
);
|
||||
|
||||
for (int slave=1; slave<Pstream::nProcs(); slave++)
|
||||
{
|
||||
IPstream fromSlave(Pstream::scheduled, slave);
|
||||
labelList polys(fromSlave);
|
||||
cellList cellFaces(fromSlave);
|
||||
faceList faces(fromSlave);
|
||||
|
||||
writePolys
|
||||
(
|
||||
polys,
|
||||
cellFaces,
|
||||
faces,
|
||||
pointOffsets[slave-1],
|
||||
ensightGeometryFile
|
||||
);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
|
||||
toMaster<< meshCellSets.polys << cellFaces << faces;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
label ensightPatchi = 2;
|
||||
|
||||
for
|
||||
(
|
||||
HashTable<labelList>::const_iterator iter = allPatchNames.begin();
|
||||
iter != allPatchNames.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
const labelList& patchProcessors = iter();
|
||||
|
||||
if (!patchNames.size() || patchNames.found(iter.key()))
|
||||
{
|
||||
const word& patchName = iter.key();
|
||||
const nFacePrims& nfp = nPatchPrims.find(patchName)();
|
||||
|
||||
const labelList *trisPtr = NULL;
|
||||
const labelList *quadsPtr = NULL;
|
||||
const labelList *polysPtr = NULL;
|
||||
|
||||
const pointField *patchPointsPtr = NULL;
|
||||
const faceList *patchFacesPtr = NULL;
|
||||
|
||||
if (patchIndices.found(iter.key()))
|
||||
{
|
||||
label patchi = patchIndices.find(iter.key())();
|
||||
const polyPatch& p = mesh.boundaryMesh()[patchi];
|
||||
|
||||
trisPtr = &boundaryFaceSets[patchi].tris;
|
||||
quadsPtr = &boundaryFaceSets[patchi].quads;
|
||||
polysPtr = &boundaryFaceSets[patchi].polys;
|
||||
|
||||
patchPointsPtr = &(p.localPoints());
|
||||
patchFacesPtr = &(p.localFaces());
|
||||
}
|
||||
|
||||
const labelList& tris = *trisPtr;
|
||||
const labelList& quads = *quadsPtr;
|
||||
const labelList& polys = *polysPtr;
|
||||
const pointField& patchPoints = *patchPointsPtr;
|
||||
const faceList& patchFaces = *patchFacesPtr;
|
||||
|
||||
if (nfp.nTris || nfp.nQuads || nfp.nPolys)
|
||||
{
|
||||
labelList patchPointOffsets(Pstream::nProcs(), 0);
|
||||
|
||||
if (Pstream::master())
|
||||
{
|
||||
ensightGeometryFile
|
||||
<< "part" << nl
|
||||
<< setw(10) << ensightPatchi++ << nl
|
||||
<< patchName << nl
|
||||
<< "coordinates" << nl
|
||||
<< setw(10) << nfp.nPoints
|
||||
<< endl;
|
||||
|
||||
for (direction d=0; d<vector::nComponents; d++)
|
||||
{
|
||||
if (patchPointsPtr)
|
||||
{
|
||||
writePoints
|
||||
(
|
||||
patchPoints.component(d),
|
||||
ensightGeometryFile
|
||||
);
|
||||
}
|
||||
|
||||
patchPointOffsets = 0;
|
||||
|
||||
forAll (patchProcessors, i)
|
||||
{
|
||||
if (patchProcessors[i] != 0)
|
||||
{
|
||||
label slave = patchProcessors[i];
|
||||
IPstream fromSlave(Pstream::scheduled, slave);
|
||||
scalarField patchPointsComponent(fromSlave);
|
||||
|
||||
writePoints
|
||||
(
|
||||
patchPointsComponent,
|
||||
ensightGeometryFile
|
||||
);
|
||||
|
||||
if (i < Pstream::nProcs()-1)
|
||||
{
|
||||
patchPointOffsets[i+1] =
|
||||
patchPointOffsets[i]
|
||||
+ patchPointsComponent.size();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (i < Pstream::nProcs()-1)
|
||||
{
|
||||
patchPointOffsets[i+1] =
|
||||
patchPointOffsets[i]
|
||||
+ patchPoints.size();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (patchPointsPtr)
|
||||
{
|
||||
for (direction d=0; d<vector::nComponents; d++)
|
||||
{
|
||||
OPstream toMaster
|
||||
(
|
||||
Pstream::scheduled,
|
||||
Pstream::masterNo()
|
||||
);
|
||||
toMaster<< patchPoints.component(d);
|
||||
}
|
||||
}
|
||||
|
||||
writeAllFacePrims
|
||||
(
|
||||
"tria3",
|
||||
tris,
|
||||
nfp.nTris,
|
||||
patchFaces,
|
||||
patchPointOffsets,
|
||||
patchProcessors,
|
||||
ensightGeometryFile
|
||||
);
|
||||
|
||||
writeAllFacePrims
|
||||
(
|
||||
"quad4",
|
||||
quads,
|
||||
nfp.nQuads,
|
||||
patchFaces,
|
||||
patchPointOffsets,
|
||||
patchProcessors,
|
||||
ensightGeometryFile
|
||||
);
|
||||
|
||||
writeAllFacePrims
|
||||
(
|
||||
"nsided",
|
||||
polys,
|
||||
nfp.nPolys,
|
||||
patchFaces,
|
||||
patchPointOffsets,
|
||||
patchProcessors,
|
||||
ensightGeometryFile
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (Pstream::master())
|
||||
{
|
||||
delete ensightGeometryFilePtr;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
Reference in New Issue
Block a user