Commit c7a7dc44 authored by Mark Olesen's avatar Mark Olesen
Browse files

extended the conversion library and utilities

library:
  * routines for managing cellTable and boundaryRegion
  * writing ensight files and parts
  * mesh reader/writer for STARCD

utils:
  * star4ToFoam
  * foamToStarMesh
  * foamToEnsightParts
parent 129e7c45
foamToStarMesh.C
EXE = $(FOAM_APPBIN)/foamToStarMesh
EXE_INC = \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/conversion/lnInclude
EXE_LIBS = \
-lconversion
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2008 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
Application
foamToStarMesh
Description
Reads an OpenFOAM mesh and writes a pro-STAR (v4) bnd/cel/vrt format.
Usage
- foamToStarMesh [OPTION] \n
Reads an OpenFOAM mesh and writes a pro-STAR (v4) bnd/cel/vrt format.
@param -noBnd \n
Suppress writing the @c .bnd file
@param -scale \<factor\>\n
Specify an alternative geometry scaling factor.
The default is @b 1000 (scale @em [m] to @em [mm]).
@param -surface \n
Extract the surface of the volume mesh only.
This can be useful, for example, for surface morphing in an external
package.
@param -tri \n
Extract a triangulated surface.
The @b -surface options is implicitly selected.
Note
The cellTable information available in the files
@c constant/cellTable and @c constant/polyMesh/cellTableId
will be used if available. Otherwise the cellZones are used when
creating the cellTable information.
See Also
Foam::cellTable, Foam::meshWriter and Foam::meshWriters::STARCD
\*---------------------------------------------------------------------------*/
#include "argList.H"
#include "Time.H"
#include "polyMesh.H"
#include "STARCDMeshWriter.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
argList::noParallel();
argList::validOptions.insert("scale", "scale");
argList::validOptions.insert("noBnd", "");
argList::validOptions.insert("tri", "");
argList::validOptions.insert("surface", "");
# include "addTimeOptions.H"
# include "setRootCase.H"
# include "createTime.H"
// Get times list
instantList Times = runTime.times();
// set startTime and endTime depending on -time and -latestTime options
# include "checkTimeOptions.H"
runTime.setTime(Times[startTime], startTime);
bool surfaceOnly = false;
if (args.options().found("surface") or args.options().found("tri"))
{
surfaceOnly = true;
}
fileName exportName = meshWriter::defaultMeshName;
if (surfaceOnly)
{
exportName = meshWriter::defaultSurfaceName;
}
if (args.options().found("case"))
{
exportName += '-' + args.globalCaseName();
}
// default: rescale from [m] to [mm]
scalar scaleFactor = 1000;
if (args.options().found("scale"))
{
scaleFactor = readScalar(IStringStream(args.options()["scale"])());
if (scaleFactor <= 0)
{
scaleFactor = 1;
}
}
# include "createPolyMesh.H"
// bool firstCheck = true;
for (label timeI = startTime; timeI < endTime; ++timeI)
{
runTime.setTime(Times[timeI], timeI);
# include "getTimeIndex.H"
polyMesh::readUpdateState state = mesh.readUpdate();
if (timeI == startTime || state != polyMesh::UNCHANGED)
{
meshWriters::STARCD writer(mesh, scaleFactor);
if (args.options().found("noBnd"))
{
writer.noBoundary();
}
fileName meshName(exportName);
if (state != polyMesh::UNCHANGED)
{
meshName += '_' + runTime.timeName();
}
if (surfaceOnly)
{
if (args.options().found("tri"))
{
writer.writeSurface(meshName, true);
}
else
{
writer.writeSurface(meshName);
}
}
else
{
writer.write(meshName);
}
}
Info<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
// ************************************************************************* //
// Read time index from */uniform/time, but treat 0 and constant specially
word timeName = "0";
if
(
runTime.timeName() != "constant"
&& runTime.timeName() != "0"
)
{
IOobject io
(
"time",
runTime.timeName(),
"uniform",
runTime,
IOobject::READ_IF_PRESENT,
IOobject::NO_WRITE,
false
);
if (io.headerOk())
{
IOdictionary timeObject
(
IOobject
(
"time",
runTime.timeName(),
"uniform",
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
label index;
timeObject.lookup("index") >> index;
timeName = Foam::name(index);
}
else
{
timeName = runTime.timeName();
// Info<< "skip ... missing entry " << io.objectPath() << endl;
// continue;
}
}
Info<< "\nTime [" << timeName << "] = " << runTime.timeName() << nl;
star4ToFoam.C
EXE = $(FOAM_APPBIN)/star4ToFoam
EXE_INC = \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/conversion/lnInclude
EXE_LIBS = \
-lconversion
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2008 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
Application
star4ToFoam
Description
Converts a Star-CD (v4) pro-STAR mesh into OpenFOAM format.
Usage
- star4ToFoam [OPTION] ccmMesh\n
convert pro-STAR mesh to OpenFOAM
@param -ascii \n
Write in ASCII format instead of binary
@param -scale \<factor\>\n
Specify an alternative geometry scaling factor.
The default is @b 0.001 (scale @em [mm] to @em [m]).
@param -solids \n
Treat any solid cells present just like fluid cells.
The default is to discard them.
Note
- baffles are written as interfaces for later use
\*---------------------------------------------------------------------------*/
#include "argList.H"
#include "Time.H"
#include "STARCDMeshReader.H"
#include "OFstream.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
argList::noParallel();
argList::validArgs.append("pro-STAR prefix");
argList::validOptions.insert("ascii", "");
argList::validOptions.insert("scale", "scale");
argList::validOptions.insert("solids", "");
argList args(argc, argv);
Time runTime(args.rootPath(), args.caseName());
stringList const& params = args.additionalArgs();
// default rescale from [mm] to [m]
scalar scaleFactor = 0.001;
if (args.options().found("scale"))
{
scaleFactor = readScalar(IStringStream(args.options()["scale"])());
if (scaleFactor <= 0)
{
scaleFactor = 1;
}
}
if (args.options().found("solids"))
{
meshReaders::STARCD::keepSolids = true;
}
// default to binary output, unless otherwise specified
IOstream::streamFormat format = IOstream::BINARY;
if (args.options().found("ascii"))
{
format = IOstream::ASCII;
}
// increase the precision of the points data
IOstream::defaultPrecision(10);
// remove extensions and/or trailing '.'
fileName prefix = fileName(params[0]).lessExt();
meshReaders::STARCD reader(prefix, runTime, scaleFactor);
autoPtr<polyMesh> mesh = reader.mesh(runTime);
reader.writeMesh(mesh, format);
Info<< "\nEnd\n" << endl;
return 0;
}
// ************************************************************************* //
......@@ -5,5 +5,5 @@ EXE_INC = \
EXE_LIBS = \
-lfiniteVolume \
-llagrangian \
-llagrangian
......@@ -24,6 +24,15 @@ License
Description
Translates FOAM data to EnSight format
Usage
- foamToEnsight [OPTION] \n
Translates OpenFOAM data to Ensight format
@param -ascii \n
Write Ensight data in ASCII format instead of "C Binary"
Note
Parallel support for cloud data is not supported
\*---------------------------------------------------------------------------*/
......@@ -74,16 +83,16 @@ bool inFileNameList
int main(int argc, char *argv[])
{
argList::validOptions.insert("patches", "patch list");
argList::validOptions.insert("binary", "" );
argList::validOptions.insert("ascii", "" );
# include "addTimeOptions.H"
# include "setRootCase.H"
// Check options
bool binary = false;
if (args.options().found("binary"))
bool binary = true;
if (args.options().found("ascii"))
{
binary = true;
binary = false;
}
# include "createTime.H"
......
foamToEnsightParts.C
EXE = $(FOAM_APPBIN)/foamToEnsightParts
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/lagrangian/basic/lnInclude \
-I$(LIB_SRC)/conversion/lnInclude
EXE_LIBS = \
-lfiniteVolume \
-llagrangian \
-lconversion
// check for lagrangian/positions information in the final directory
bool hasLagrangian = false;
if (timeDirs.size() > 1)
{
IOobject io
(
"positions",
timeDirs[timeDirs.size() - 1].name(),
"lagrangian",
mesh,
IOobject::NO_READ
);
if (io.headerOk())
{
hasLagrangian = true;
}
}
// check for "points" in all of the result directories
bool hasMovingMesh = false;
if (timeDirs.size() > 1)
{
hasMovingMesh = true;
for (label i=0; i < timeDirs.size() && hasMovingMesh; ++i)
{
IOobject io
(
"points",
timeDirs[i].name(),
polyMesh::meshSubDir,
mesh,
IOobject::NO_READ
);
hasMovingMesh = io.headerOk();
}
}
// check that the spray variable is present for this time
//
bool hasSprayField = true;
{
IOobject ioHeader
(
fieldName,
mesh.time().timeName(),
"lagrangian",
mesh,
IOobject::NO_READ
);
hasSprayField = ioHeader.headerOk();
}
// check that the variable is present for all times
//
bool hasValidField = true;
{
for (label i=0; i < timeDirs.size() && hasValidField; ++i)
{
if (fieldName.size() > 2 && fieldName(fieldName.size() - 2, 2) == "_0")
{
hasValidField = false;
break;
}
IOobject ioHeader
(
fieldName,
timeDirs[i].name(),
mesh,
IOobject::NO_READ
);
hasValidField = ioHeader.headerOk();
}
}
// write time values to case file
{
scalar timeCorrection = 0;
if (timeDirs[0].value() < 0)
{
timeCorrection = - timeDirs[0].value();
Info<< "Correcting time values. Adding " << timeCorrection << endl;
}
caseFile.setf(ios_base::scientific, ios_base::floatfield);
caseFile.precision(5);
// time set 1 - geometry and volume fields
if (fieldFileNumbers.size())
{
caseFile
<< "time set: " << 1 << nl
<< "number of steps: " << fieldFileNumbers.size() << nl
<< "filename numbers:" << nl;
label count = 0;
forAll (fieldFileNumbers, i)
{
caseFile
<< " " << setw(12) << fieldFileNumbers[i];
if (++count % 6 == 0)
{
caseFile << nl;
}
}
caseFile
<< nl << "time values:" << nl;
count = 0;
forAll (fieldFileNumbers, i)
{
caseFile
<< " " << setw(12)
<< timeIndices[fieldFileNumbers[i]] + timeCorrection;
if (++count % 6 == 0)
{
caseFile << nl;
}
}
caseFile << nl << nl;
}
// time set 2 - lagrangian fields
if (hasLagrangian && sprayFileNumbers.size())
{
caseFile
<< "time set: " << 2 << nl
<< "number of steps: " << sprayFileNumbers.size() << nl
<< "filename numbers:" << nl;
label count = 0;
forAll (sprayFileNumbers, i)
{
caseFile
<< " " << setw(12) << sprayFileNumbers[i];
if (++count % 6 == 0)
{
caseFile << nl;
}
}
caseFile
<< nl << "time values:" << nl;