a72b12ce8f
not completely instantiated in objectRegistry (see error message
below)
By including objectRegistry.H before Time.H the class Tiem gets
completely defined before objectRegistry.
The original Time.H could be omitted (as it is already included in
objectRegistry.H )
In file included from blockMeshApp.C:49:
In file included from /Users/bgschaid/OpenFOAM/foam-extend-3.1/src/foam/lnInclude/Time.H:42:
In file included from /Users/bgschaid/OpenFOAM/foam-extend-3.1/src/foam/lnInclude/objectRegistry.H:235:
/Users/bgschaid/OpenFOAM/foam-extend-3.1/src/foam/lnInclude/objectRegistryTemplates.C:94:25: error: 'const Foam::Time' is an incomplete type
if (&parent_ != dynamic_cast<const objectRegistry*>(&time_))
^ ~~~~~~
/Users/bgschaid/OpenFOAM/foam-extend-3.1/src/foam/lnInclude/IOobject.H:78:7: note: forward declaration of 'Foam::Time'
class Time;
^
In file included from blockMeshApp.C:49:
707 lines
19 KiB
C++
707 lines
19 KiB
C++
/*--------------------------------*- C++ -*----------------------------------*\
|
|
========= |
|
|
\\ / F ield | foam-extend: Open Source CFD
|
|
\\ / O peration |
|
|
\\ / A nd | For copyright notice see file Copyright
|
|
\\/ M anipulation |
|
|
-------------------------------------------------------------------------------
|
|
License
|
|
This file is part of foam-extend.
|
|
|
|
foam-extend 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 3 of the License, or (at your
|
|
option) any later version.
|
|
|
|
foam-extend 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 foam-extend. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
Application
|
|
ansysToFoam
|
|
|
|
Description
|
|
Converts an ANSYS input mesh file, exported from I-DEAS, to FOAM format.
|
|
|
|
\*---------------------------------------------------------------------------*/
|
|
|
|
%{
|
|
|
|
#undef yyFlexLexer
|
|
|
|
/* ------------------------------------------------------------------------- *\
|
|
------ local definitions
|
|
\* ------------------------------------------------------------------------- */
|
|
|
|
#include <sstream>
|
|
// For EOF only
|
|
#include <cstdio>
|
|
|
|
#include "scalar.H"
|
|
#include "IStringStream.H"
|
|
|
|
using namespace Foam;
|
|
|
|
#include "argList.H"
|
|
#include "objectRegistry.H"
|
|
#include "Time.H"
|
|
#include "polyMesh.H"
|
|
#include "emptyPolyPatch.H"
|
|
#include "preservePatchTypes.H"
|
|
#include "cellShape.H"
|
|
#include "cellModeller.H"
|
|
#include "SLList.H"
|
|
#include "SLPtrList.H"
|
|
|
|
SLList<point> slPoints;
|
|
SLList<label> slPointMap;
|
|
label maxNodei = 0;
|
|
|
|
SLPtrList<labelList> slCellLabels;
|
|
SLList<label> slCellMap;
|
|
SLList<label> slCellType;
|
|
label maxCelli = 0;
|
|
|
|
PtrList<SLList<label> > slPatchCells;
|
|
PtrList<SLList<label> > slPatchCellFaces;
|
|
|
|
// Cell types
|
|
Map<word> cellTypes;
|
|
label currentTypei = -1;
|
|
|
|
|
|
// Dummy yywrap to keep yylex happy at compile time.
|
|
// It is called by yylex but is not used as the mechanism to change file.
|
|
// See <<EOF>>
|
|
#if YY_FLEX_SUBMINOR_VERSION < 34
|
|
extern "C" int yywrap()
|
|
#else
|
|
int yyFlexLexer::yywrap()
|
|
#endif
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
%}
|
|
|
|
one_space [ \t\f\r]
|
|
space {one_space}*
|
|
some_space {one_space}+
|
|
cspace ","{space}
|
|
|
|
alpha [_A-Za-z]
|
|
digit [0-9]
|
|
|
|
identifier {alpha}({alpha}|{digit})*
|
|
integer {digit}+
|
|
label [1-9]{digit}*
|
|
|
|
exponent_part [eE][-+]?{digit}+
|
|
fractional_constant [-+]?(({digit}*"."{digit}+)|({digit}+"."?))
|
|
|
|
floatNum (({fractional_constant}{exponent_part}?)|({digit}+{exponent_part}))
|
|
|
|
x {floatNum}
|
|
y {floatNum}
|
|
z {floatNum}
|
|
value {floatNum}
|
|
|
|
node ^{space}"N"{cspace}
|
|
element ^{space}"EN"{cspace}
|
|
bface ^{space}"SFE"{cspace}
|
|
elementTypeName ^{space}"ET"{cspace}
|
|
elementType ^{space}"TYPE"{cspace}
|
|
|
|
|
|
%%
|
|
|
|
%{
|
|
labelList labels(8);
|
|
%}
|
|
|
|
|
|
/* ------------------------------------------------------------------------- *\
|
|
------ Start Lexing ------
|
|
\* ------------------------------------------------------------------------- */
|
|
|
|
{node}{label}{cspace}{x}{cspace}{y}{cspace}{z}{space}\n {
|
|
IStringStream nodeStream(YYText());
|
|
char tag, c;
|
|
label nodei;
|
|
point node;
|
|
nodeStream
|
|
>> tag
|
|
>> c >> nodei
|
|
>> c >> node.x()
|
|
>> c >> node.y()
|
|
>> c >> node.z();
|
|
|
|
if (nodei > maxNodei) maxNodei = nodei;
|
|
|
|
slPointMap.append(nodei);
|
|
slPoints.append(node);
|
|
}
|
|
|
|
|
|
{element}{label}{cspace}{label}{cspace}{label}{cspace}{label}{cspace}{label}{cspace}{label}{cspace}{label}{cspace}{label}{cspace}{label}{space}\n {
|
|
IStringStream elementStream(YYText());
|
|
char tag, c;
|
|
label celli;
|
|
elementStream
|
|
>> tag >> tag
|
|
>> c >> celli
|
|
>> c >> labels[0]
|
|
>> c >> labels[1]
|
|
>> c >> labels[2]
|
|
>> c >> labels[3]
|
|
>> c >> labels[4]
|
|
>> c >> labels[5]
|
|
>> c >> labels[6]
|
|
>> c >> labels[7];
|
|
|
|
if (celli > maxCelli) maxCelli = celli;
|
|
|
|
slCellMap.append(celli);
|
|
slCellLabels.append(new labelList(labels));
|
|
slCellType.append(currentTypei);
|
|
}
|
|
|
|
|
|
{bface}{label}{cspace}{label}{cspace}{identifier}{cspace}{integer}{cspace}{value}{space}\n {
|
|
IStringStream bfaceStream(YYText());
|
|
char tag, c;
|
|
label elementi;
|
|
label facei;
|
|
scalar indexValue, unknown;
|
|
bfaceStream
|
|
>> tag >> tag >> tag
|
|
>> c >> elementi
|
|
>> c >> facei
|
|
>> c >> tag >> tag >> tag >> tag
|
|
>> c >> unknown
|
|
>> c >> indexValue;
|
|
|
|
label patchi = label(indexValue);
|
|
|
|
if (patchi > slPatchCells.size())
|
|
{
|
|
slPatchCells.setSize(patchi);
|
|
|
|
forAll(slPatchCells, i)
|
|
{
|
|
if (!slPatchCells(i))
|
|
{
|
|
slPatchCells.set(i, new SLList<label>);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (patchi > slPatchCellFaces.size())
|
|
{
|
|
slPatchCellFaces.setSize(patchi);
|
|
|
|
forAll(slPatchCells, i)
|
|
{
|
|
if (!slPatchCellFaces(i))
|
|
{
|
|
slPatchCellFaces.set(i, new SLList<label>);
|
|
}
|
|
}
|
|
}
|
|
|
|
slPatchCells[patchi-1].append(elementi);
|
|
slPatchCellFaces[patchi-1].append(facei);
|
|
}
|
|
|
|
|
|
{elementTypeName}{label}{cspace}{identifier}{space}\n {
|
|
|
|
IStringStream elementStream(YYText());
|
|
char tag,c;
|
|
label cellTypei;
|
|
word cellTypeName;
|
|
elementStream
|
|
>> tag >> tag // skip 'ET'
|
|
>> c >> cellTypei
|
|
>> c >> cellTypeName;
|
|
|
|
Info<< "Read typeName " << cellTypeName
|
|
<< " for type " << cellTypei << endl;
|
|
|
|
cellTypes.insert(cellTypei, cellTypeName);
|
|
}
|
|
|
|
|
|
{elementType}{label}{space}\n {
|
|
IStringStream elementStream(YYText());
|
|
char tag,c;
|
|
label cellTypei;
|
|
elementStream
|
|
>> tag >> tag >> tag >> tag // skip 'TYPE'
|
|
>> c >> cellTypei;
|
|
|
|
currentTypei = cellTypei;
|
|
}
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------------------- *\
|
|
------ Ignore remaining space and \n s. Any other characters are errors.
|
|
\* ------------------------------------------------------------------------- */
|
|
|
|
.|\n {}
|
|
|
|
|
|
/* ------------------------------------------------------------------------- *\
|
|
------ On EOF return to previous file, if none exists terminate.
|
|
\* ------------------------------------------------------------------------- */
|
|
|
|
<<EOF>> {
|
|
yyterminate();
|
|
}
|
|
%%
|
|
|
|
|
|
#include "fileName.H"
|
|
#include <fstream>
|
|
using std::ifstream;
|
|
|
|
|
|
label findFace(const polyMesh& mesh, const face& f)
|
|
{
|
|
const labelList& pFaces = mesh.pointFaces()[f[0]];
|
|
|
|
forAll(pFaces, i)
|
|
{
|
|
label faceI = pFaces[i];
|
|
|
|
if (mesh.faces()[faceI] == f)
|
|
{
|
|
return faceI;
|
|
}
|
|
}
|
|
|
|
FatalErrorIn("findFace(const polyMesh&, const face&)")
|
|
<< "Cannot find a face matching " << f
|
|
<< exit(FatalError);
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
argList::noParallel();
|
|
argList::validArgs.append("ANSYS input file");
|
|
argList::validOptions.insert("scale", "scale factor");
|
|
|
|
argList args(argc, argv);
|
|
|
|
if (!args.check())
|
|
{
|
|
FatalError.exit();
|
|
}
|
|
|
|
scalar scaleFactor = 1.0;
|
|
args.optionReadIfPresent("scale", scaleFactor);
|
|
|
|
# include "createTime.H"
|
|
|
|
fileName ansysFile(args.additionalArgs()[0]);
|
|
ifstream ansysStream(ansysFile.c_str());
|
|
|
|
if (!ansysStream)
|
|
{
|
|
FatalErrorIn("ansysToFoam::main(int argc, char *argv[])")
|
|
<< args.executable()
|
|
<< ": file " << ansysFile << " not found"
|
|
<< exit(FatalError);
|
|
}
|
|
|
|
yyFlexLexer lexer(&ansysStream);
|
|
while (lexer.yylex() != 0)
|
|
{}
|
|
|
|
Info<< "Creating points" << endl;
|
|
|
|
pointField points(slPoints.size());
|
|
|
|
label i = 0;
|
|
forAllConstIter(SLList<point>, slPoints, pointIter)
|
|
{
|
|
// Scale points for the given scale factor
|
|
points[i++] = scaleFactor * pointIter();
|
|
}
|
|
|
|
|
|
labelList pointMap(maxNodei+1);
|
|
|
|
i = 0;
|
|
forAllConstIter(SLList<label>, slPointMap, pointMapIter)
|
|
{
|
|
pointMap[pointMapIter()] = i++;
|
|
}
|
|
|
|
Info<< "Creating cells" << endl;
|
|
|
|
labelList cellMap(maxCelli+1);
|
|
|
|
i = 0;
|
|
forAllConstIter(SLList<label>, slCellMap, cellMapIter)
|
|
{
|
|
cellMap[cellMapIter()] = i++;
|
|
}
|
|
|
|
|
|
const cellModel& hex = *(cellModeller::lookup("hex"));
|
|
const cellModel& prism = *(cellModeller::lookup("prism"));
|
|
const cellModel& pyr = *(cellModeller::lookup("pyr"));
|
|
const cellModel& tet = *(cellModeller::lookup("tet"));
|
|
|
|
labelList labelsHex(8);
|
|
labelList labelsPrism(6);
|
|
labelList labelsPyramid(5);
|
|
labelList labelsTet(4);
|
|
|
|
cellShapeList cellShapes(slCellLabels.size());
|
|
label nCells = 0;
|
|
|
|
forAllConstIter(SLPtrList<labelList>, slCellLabels, cellIter)
|
|
{
|
|
if // Tetrahedron
|
|
(
|
|
cellIter()[2] == cellIter()[3]
|
|
&& cellIter()[4] == cellIter()[5]
|
|
&& cellIter()[5] == cellIter()[6]
|
|
&& cellIter()[6] == cellIter()[7]
|
|
)
|
|
{
|
|
labelsTet[0] = pointMap[cellIter()[0] ];
|
|
labelsTet[1] = pointMap[cellIter()[1] ];
|
|
labelsTet[2] = pointMap[cellIter()[2] ];
|
|
labelsTet[3] = pointMap[cellIter()[4] ];
|
|
|
|
cellShapes[nCells++] = cellShape(tet, labelsTet);
|
|
}
|
|
|
|
else if // Square-based pyramid
|
|
(
|
|
cellIter()[4] == cellIter()[5]
|
|
&& cellIter()[5] == cellIter()[6]
|
|
&& cellIter()[6] == cellIter()[7]
|
|
)
|
|
{
|
|
labelsPyramid[0] = pointMap[cellIter()[0] ];
|
|
labelsPyramid[1] = pointMap[cellIter()[1] ];
|
|
labelsPyramid[2] = pointMap[cellIter()[2] ];
|
|
labelsPyramid[3] = pointMap[cellIter()[3] ];
|
|
labelsPyramid[4] = pointMap[cellIter()[4] ];
|
|
|
|
cellShapes[nCells++] = cellShape(pyr, labelsPyramid);
|
|
}
|
|
|
|
else if // Triangular prism
|
|
(
|
|
cellIter()[2] == cellIter()[3]
|
|
&& cellIter()[6] == cellIter()[7]
|
|
)
|
|
{
|
|
labelsPrism[0] = pointMap[cellIter()[0] ];
|
|
labelsPrism[1] = pointMap[cellIter()[1] ];
|
|
labelsPrism[2] = pointMap[cellIter()[2] ];
|
|
labelsPrism[3] = pointMap[cellIter()[4] ];
|
|
labelsPrism[4] = pointMap[cellIter()[5] ];
|
|
labelsPrism[5] = pointMap[cellIter()[6] ];
|
|
|
|
cellShapes[nCells++] = cellShape(prism, labelsPrism);
|
|
}
|
|
|
|
else // Hex
|
|
{
|
|
labelsHex[0] = pointMap[cellIter()[0] ];
|
|
labelsHex[1] = pointMap[cellIter()[1] ];
|
|
labelsHex[2] = pointMap[cellIter()[2] ];
|
|
labelsHex[3] = pointMap[cellIter()[3] ];
|
|
labelsHex[4] = pointMap[cellIter()[4] ];
|
|
labelsHex[5] = pointMap[cellIter()[5] ];
|
|
labelsHex[6] = pointMap[cellIter()[6] ];
|
|
labelsHex[7] = pointMap[cellIter()[7] ];
|
|
|
|
cellShapes[nCells++] = cellShape(hex, labelsHex);
|
|
}
|
|
}
|
|
|
|
|
|
const word defaultFacesName = "defaultFaces";
|
|
word defaultFacesType = emptyPolyPatch::typeName;
|
|
|
|
// Create dummy mesh just to find out what are internal/external
|
|
// faces
|
|
autoPtr<polyMesh> dummyMesh
|
|
(
|
|
new polyMesh
|
|
(
|
|
IOobject
|
|
(
|
|
"dummyMesh",
|
|
runTime.constant(),
|
|
runTime
|
|
),
|
|
xferCopy(points),
|
|
cellShapes,
|
|
faceListList(0),
|
|
wordList(0),
|
|
wordList(0),
|
|
defaultFacesName,
|
|
defaultFacesType,
|
|
wordList(0)
|
|
)
|
|
);
|
|
|
|
|
|
// Warning: tet face order has changed between version 1.9.6 and 2.0
|
|
//
|
|
label faceIndex[7][6] =
|
|
{
|
|
{-1, -1, -1, -1, -1, -1}, // 0
|
|
{-1, -1, -1, -1, -1, -1}, // 1
|
|
{-1, -1, -1, -1, -1, -1}, // 2
|
|
{-1, -1, -1, -1, -1, -1}, // 3
|
|
{ 3, 2, 0, -1, 1, -1}, // tet (version 2.0)
|
|
{ 0, 4, 3, -1, 2, 1}, // prism
|
|
{ 4, 2, 1, 3, 0, 5}, // hex
|
|
};
|
|
|
|
Info<< "Creating boundary patches" << endl;
|
|
|
|
faceListList boundary(slPatchCells.size());
|
|
wordList patchNames(slPatchCells.size());
|
|
|
|
forAll(slPatchCells, patchI)
|
|
{
|
|
SLList<face> patchFaces;
|
|
|
|
SLList<label>::iterator cellIter(slPatchCells[patchI].begin());
|
|
SLList<label>::iterator faceIter(slPatchCellFaces[patchI].begin());
|
|
|
|
for
|
|
(
|
|
;
|
|
cellIter != slPatchCells[patchI].end()
|
|
&& faceIter != slPatchCellFaces[patchI].end();
|
|
++cellIter, ++faceIter
|
|
)
|
|
{
|
|
const cellShape& shape = cellShapes[cellMap[cellIter()]];
|
|
|
|
patchFaces.append
|
|
(
|
|
shape.faces()
|
|
[
|
|
faceIndex
|
|
[shape.nFaces()]
|
|
[faceIter()-1]
|
|
]
|
|
);
|
|
}
|
|
|
|
boundary[patchI] = patchFaces;
|
|
patchNames[patchI] = word("patch") + name(patchI + 1);
|
|
}
|
|
|
|
|
|
//
|
|
// Lookup the face labels for all the boundary faces
|
|
//
|
|
labelListList boundaryFaceLabels(boundary.size());
|
|
forAll(boundary, patchI)
|
|
{
|
|
const faceList& bFaces = boundary[patchI];
|
|
labelList& bFaceLabels = boundaryFaceLabels[patchI];
|
|
bFaceLabels.setSize(bFaces.size());
|
|
forAll(bFaces, i)
|
|
{
|
|
bFaceLabels[i] = findFace(dummyMesh(), bFaces[i]);
|
|
}
|
|
}
|
|
|
|
|
|
// Now split the boundary faces into external and internal faces. All
|
|
// faces go into faceZones and external faces go into patches.
|
|
List<faceList> patchFaces(slPatchCells.size());
|
|
labelList patchNFaces(slPatchCells.size(), 0);
|
|
forAll(boundary, patchI)
|
|
{
|
|
const faceList& bFaces = boundary[patchI];
|
|
const labelList& bFaceLabels = boundaryFaceLabels[patchI];
|
|
|
|
patchFaces[patchI].setSize(bFaces.size());
|
|
|
|
forAll(bFaces, i)
|
|
{
|
|
if (!dummyMesh().isInternalFace(bFaceLabels[i]))
|
|
{
|
|
patchFaces[patchI][patchNFaces[patchI]++] = bFaces[i];
|
|
}
|
|
}
|
|
patchFaces[patchI].setSize(patchNFaces[patchI]);
|
|
|
|
Info<< "Patch " << patchI << " named " << patchNames[patchI]
|
|
<< ": " << boundary[patchI].size() << " faces" << endl;
|
|
}
|
|
|
|
// We no longer need the dummyMesh
|
|
dummyMesh.clear();
|
|
|
|
|
|
Info<< "ansysToFoam: " << endl
|
|
<< "Ansys file format does not provide information about the type of "
|
|
<< "the patch (eg. wall, symmetry plane, cyclic etc)." << endl
|
|
<< "All the patches have been created "
|
|
<< "as type patch. Please reset after mesh conversion as necessary."
|
|
<< endl;
|
|
|
|
PtrList<dictionary> patchDicts;
|
|
|
|
preservePatchTypes
|
|
(
|
|
runTime,
|
|
runTime.constant(),
|
|
polyMesh::meshSubDir,
|
|
patchNames,
|
|
patchDicts,
|
|
defaultFacesName,
|
|
defaultFacesType
|
|
);
|
|
|
|
// Add information to dictionary
|
|
forAll(patchNames, patchI)
|
|
{
|
|
if (!patchDicts.set(patchI))
|
|
{
|
|
patchDicts.set(patchI, new dictionary());
|
|
}
|
|
// Add but not overwrite
|
|
patchDicts[patchI].add("type", polyPatch::typeName, false);
|
|
}
|
|
|
|
|
|
polyMesh pShapeMesh
|
|
(
|
|
IOobject
|
|
(
|
|
polyMesh::defaultRegion,
|
|
runTime.constant(),
|
|
runTime
|
|
),
|
|
xferMove(points),
|
|
cellShapes,
|
|
patchFaces,
|
|
patchNames,
|
|
patchDicts,
|
|
defaultFacesName,
|
|
defaultFacesType
|
|
);
|
|
|
|
|
|
if (cellTypes.size() > 0 || patchNames.size() > 0)
|
|
{
|
|
DynamicList<pointZone*> pz;
|
|
DynamicList<faceZone*> fz;
|
|
DynamicList<cellZone*> cz;
|
|
|
|
// FaceZones
|
|
forAll(boundaryFaceLabels, patchI)
|
|
{
|
|
if (boundaryFaceLabels[patchI].size())
|
|
{
|
|
// Re-do the boundaryFaceLabels since the boundary face
|
|
// labels will be different on the pShapeMesh.
|
|
const faceList& bFaces = boundary[patchI];
|
|
labelList& bFaceLabels = boundaryFaceLabels[patchI];
|
|
forAll(bFaceLabels, i)
|
|
{
|
|
bFaceLabels[i] = findFace(pShapeMesh, bFaces[i]);
|
|
}
|
|
|
|
Info<< "Creating faceZone " << patchNames[patchI]
|
|
<< " with " << bFaceLabels.size() << " faces" << endl;
|
|
|
|
fz.append
|
|
(
|
|
new faceZone
|
|
(
|
|
patchNames[patchI],
|
|
bFaceLabels,
|
|
boolList(bFaceLabels.size(), false),
|
|
fz.size(),
|
|
pShapeMesh.faceZones()
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
// CellZones
|
|
labelList types = cellTypes.toc();
|
|
|
|
forAll(types, j)
|
|
{
|
|
label cellType = types[j];
|
|
|
|
// Pick up cells in zone
|
|
DynamicList<label> addr;
|
|
|
|
SLList<label>::iterator cellMapIter = slCellMap.begin();
|
|
SLList<label>::iterator typeIter = slCellType.begin();
|
|
|
|
for
|
|
(
|
|
;
|
|
typeIter != slCellType.end();
|
|
++typeIter, ++cellMapIter
|
|
)
|
|
{
|
|
if (typeIter() == cellType)
|
|
{
|
|
addr.append(cellMap[cellMapIter()]);
|
|
}
|
|
}
|
|
|
|
Info<< "Creating cellZone " << cellTypes[cellType]
|
|
<< " with " << addr.size() << " cells" << endl;
|
|
|
|
cz.append
|
|
(
|
|
new cellZone
|
|
(
|
|
cellTypes[cellType],
|
|
addr,
|
|
j,
|
|
pShapeMesh.cellZones()
|
|
)
|
|
);
|
|
}
|
|
|
|
pShapeMesh.addZones(pz, fz, cz);
|
|
}
|
|
|
|
|
|
// Set the precision of the points data to 10
|
|
IOstream::defaultPrecision(max(10u, IOstream::defaultPrecision()));
|
|
|
|
Info<< "Writing polyMesh" << endl;
|
|
pShapeMesh.write();
|
|
|
|
Info<< nl << "end" << endl;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------------------- *\
|
|
------ End of ansysToFoam.L
|
|
\* ------------------------------------------------------------------------- */
|