zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Mark's correction to the building of libccmio.so

Browse Source
This commit is contained in:
henry
2008-06-09 13:37:13 +01:00
parent 232e3db40a
commit 91c5607c97
22 changed files with 10 additions and 2910 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
applications/utilities/mesh/conversion/Optional/AllwmakeOptional
View File

@ -2,11 +2,18 @@
# Build optional components (eg, may depend on third-party libraries)
set -x
# if the library exists, assume there are headers too
# build libccmio if required
if [ ! -e $FOAM_LIBBIN/libccmio.so ]
then
(
cd $WM_PROJECT_DIR/../ThirdParty && ./AllwmakeLibccmio
)
fi
# if the library built okay, the headers must exist too
if [ -e $FOAM_LIBBIN/libccmio.so ]
then
( cd $WM_PROJECT_DIR/../ThirdParty && ./AllwmakeLibccmio ) \
&& wmake ccm26ToFoam
wmake ccm26ToFoam
fi
# end

6
applications/utilities/postProcessing/dataConversion/foamToEnsight/Make/files
View File

@ -1,6 +0,0 @@
itoa.C
ensightMesh.C
ensightParticlePositions.C
foamToEnsight.C
EXE = $(FOAM_APPBIN)/foamToEnsight

8
applications/utilities/postProcessing/dataConversion/foamToEnsight/Make/options
View File

@ -1,8 +0,0 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/lagrangian/basic/lnInclude
EXE_LIBS = \
-lfiniteVolume \
-llagrangian \

102
applications/utilities/postProcessing/dataConversion/foamToEnsight/cellSets.H
View File

@ -1,102 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
Class
Foam::cellSets
Description
\*---------------------------------------------------------------------------*/
#ifndef cellSets_H
#define cellSets_H
#include "labelList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cellSets Declaration
\*---------------------------------------------------------------------------*/
class cellSets
{
// Private Member Functions
//- Disallow default bitwise copy construct
cellSets(const cellSets&);
//- Disallow default bitwise assignment
void operator=(const cellSets&);
public:
label nHexesWedges;
label nPrisms;
label nPyrs;
label nTets;
label nPolys;
labelList tets;
labelList pyrs;
labelList prisms;
labelList wedges;
labelList hexes;
labelList polys;
// Constructors
//- Construct given the number ov cells
cellSets(const label nCells)
:
nHexesWedges(0),
nPrisms(0),
nPyrs(0),
nTets(0),
nPolys(0),
tets(nCells),
pyrs(nCells),
prisms(nCells),
wedges(nCells),
hexes(nCells),
polys(nCells)
{}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

18
applications/utilities/postProcessing/dataConversion/foamToEnsight/checkData.H
View File

@ -1,18 +0,0 @@
for (int n1=startTime; n1<endTime; n1++)
{
if (fieldName.size() > 2 && fieldName(fieldName.size() - 2, 2) == "_0")
{
variableGood = false;
break;
}
IOobject fieldObjectHeader
(
fieldName,
Times[n1].name(),
mesh,
IOobject::NO_READ
);
variableGood = variableGood && fieldObjectHeader.headerOk();
}

20
applications/utilities/postProcessing/dataConversion/foamToEnsight/checkMeshMoving.H
View File

@ -1,20 +0,0 @@
bool meshMoving = true;
if (Times.size() > 2)
{
for(label n2=2; n2<Times.size(); n2++)
{
IOobject tmpPoints
(
"points",
Times[n2].name(),
polyMesh::meshSubDir,
mesh,
IOobject::NO_READ
);
meshMoving = meshMoving && tmpPoints.headerOk();
}
}
else
{
meshMoving = false;
}

13
applications/utilities/postProcessing/dataConversion/foamToEnsight/checkSprayData.H
View File

@ -1,13 +0,0 @@
forAll(Times, n1)
{
IOobject fieldObjectHeader
(
fieldName,
Times[n1].name(),
"lagrangian",
mesh,
IOobject::NO_READ
);
variableGood = variableGood && fieldObjectHeader.headerOk();
}

5
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCaseHeader.H
View File

@ -1,5 +0,0 @@
if (Pstream::master())
{
ensightCaseFile << "FORMAT" << nl;
ensightCaseFile << "type: ensight gold" << nl << nl;
}

33
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCaseTail.H
View File

@ -1,33 +0,0 @@
if (Pstream::master())
{
ensightCaseFile << nl << "TIME" << nl
<< "time set: " << 1 << nl
<< "number of steps: " << nTimeSteps << nl
<< "filename start number: " << 0 << nl
<< "filename increment: " << 1 << nl;
ensightCaseFile << "time values:" << nl;
ensightCaseFile.setf(ios_base::scientific, ios_base::floatfield);
ensightCaseFile.precision(5);
label count = 0;
scalar Tcorr = 0.0;
if (Times[0].value() < 0)
{
Tcorr = - Times[0].value();
Info << "Correcting time values. Adding " << Tcorr << endl;
}
for (int n=startTime; n<endTime; n++)
{
ensightCaseFile << setw(12) << Times[n].value() + Tcorr << " ";
if (++count % 6 == 0)
{
ensightCaseFile << nl;
}
}
ensightCaseFile << nl;
}

537
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.C
View File

@ -1,537 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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 "ensightField.H"
#include "fvMesh.H"
#include "volFields.H"
#include "OFstream.H"
#include "IOmanip.H"
#include "itoa.H"
using namespace Foam;
// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
void writeData(const scalarField& sf, OFstream& ensightFile)
{
forAll(sf, i)
{
ensightFile << setw(12) << float(sf[i]) << nl;
}
}
template<class Type>
scalarField map
(
const Field<Type>& vf,
const labelList& map,
const label cmpt
)
{
scalarField mf(map.size());
forAll(map, i)
{
mf[i] = component(vf[map[i]], cmpt);
}
return mf;
}
template<class Type>
scalarField map
(
const Field<Type>& vf,
const labelList& map1,
const labelList& map2,
const label cmpt
)
{
scalarField mf(map1.size() + map2.size());
forAll(map1, i)
{
mf[i] = component(vf[map1[i]], cmpt);
}
label offset = map1.size();
forAll(map2, i)
{
mf[i + offset] = component(vf[map2[i]], cmpt);
}
return mf;
}
template<class Type>
void writeAllData
(
const char* key,
const Field<Type>& vf,
const labelList& prims,
const label nPrims,
OFstream& ensightFile
)
{
if (nPrims)
{
if (Pstream::master())
{
ensightFile << key << nl;
for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
{
writeData(map(vf, prims, cmpt), ensightFile);
for (int slave=1; slave<Pstream::nProcs(); slave++)
{
IPstream fromSlave(Pstream::scheduled, slave);
scalarField data(fromSlave);
writeData(data, ensightFile);
}
}
}
else
{
for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
{
OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
toMaster<< map(vf, prims, cmpt);
}
}
}
}
template<class Type>
void writeAllFaceData
(
const char* key,
const labelList& prims,
const label nPrims,
const Field<Type>& pf,
const labelList& patchProcessors,
OFstream& ensightFile
)
{
if (nPrims)
{
if (Pstream::master())
{
ensightFile << key << nl;
for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
{
writeData(map(pf, prims, cmpt), ensightFile);
forAll (patchProcessors, i)
{
if (patchProcessors[i] != 0)
{
label slave = patchProcessors[i];
IPstream fromSlave(Pstream::scheduled, slave);
scalarField pf(fromSlave);
writeData(pf, ensightFile);
}
}
}
}
else
{
for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
{
OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
toMaster<< map(pf, prims, cmpt);
}
}
}
}
template<class Type>
bool writePatchField
(
const Foam::Field<Type>& pf,
const Foam::label patchi,
const Foam::label ensightPatchi,
const Foam::faceSets& boundaryFaceSet,
const Foam::ensightMesh::nFacePrims& nfp,
const Foam::labelList& patchProcessors,
Foam::OFstream& ensightFile
)
{
if (nfp.nTris || nfp.nQuads || nfp.nPolys)
{
if (Pstream::master())
{
ensightFile
<< "part" << nl
<< setw(10) << ensightPatchi << nl;
}
writeAllFaceData
(
"tria3",
boundaryFaceSet.tris,
nfp.nTris,
pf,
patchProcessors,
ensightFile
);
writeAllFaceData
(
"quad4",
boundaryFaceSet.quads,
nfp.nQuads,
pf,
patchProcessors,
ensightFile
);
writeAllFaceData
(
"nsided",
boundaryFaceSet.polys,
nfp.nPolys,
pf,
patchProcessors,
ensightFile
);
return true;
}
else
{
return false;
}
}
template<class Type>
void writePatchField
(
const Foam::word& fieldName,
const Foam::Field<Type>& pf,
const Foam::word& patchName,
const Foam::ensightMesh& eMesh,
const Foam::fileName& postProcPath,
const Foam::word& prepend,
const Foam::label timeIndex,
Foam::Ostream& ensightCaseFile
)
{
const Time& runTime = eMesh.mesh.time();
const List<faceSets>& boundaryFaceSets = eMesh.boundaryFaceSets;
const HashTable<labelList>& allPatchNames = eMesh.allPatchNames;
const HashTable<label>& patchIndices = eMesh.patchIndices;
const HashTable<ensightMesh::nFacePrims>& nPatchPrims = eMesh.nPatchPrims;
label patchi = -1;
if (patchIndices.found(patchName))
{
patchi = patchIndices.find(patchName)();
}
label ensightPatchi = 2;
for
(
HashTable<labelList>::const_iterator iter =
allPatchNames.begin();
iter != allPatchNames.end();
++iter
)
{
if (iter.key() == patchName) break;
ensightPatchi++;
}
const labelList& patchProcessors = allPatchNames.find(patchName)();
word pfName = patchName + '.' + fieldName;
word timeFile = prepend + itoa(timeIndex);
OFstream *ensightFilePtr = NULL;
if (Pstream::master())
{
if (timeIndex == 0)
{
ensightCaseFile.setf(ios_base::left);
ensightCaseFile
<< pTraits<Type>::typeName
<< " per element: 1 "
<< setw(15) << pfName
<< (' ' + prepend + "***." + pfName).c_str()
<< nl;
}
// set the filename of the ensight file
fileName ensightFileName(timeFile + "." + pfName);
ensightFilePtr = new OFstream
(
postProcPath/ensightFileName,
runTime.writeFormat(),
runTime.writeVersion(),
runTime.writeCompression()
);
}
OFstream& ensightFile = *ensightFilePtr;
if (Pstream::master())
{
ensightFile << pTraits<Type>::typeName << nl;
}
if (patchi >= 0)
{
writePatchField
(
pf,
patchi,
ensightPatchi,
boundaryFaceSets[patchi],
nPatchPrims.find(patchName)(),
patchProcessors,
ensightFile
);
}
else
{
faceSets nullFaceSets;
writePatchField
(
Field<Type>(),
-1,
ensightPatchi,
nullFaceSets,
nPatchPrims.find(patchName)(),
patchProcessors,
ensightFile
);
}
if (Pstream::master())
{
delete ensightFilePtr;
}
}
template<class Type>
void ensightField
(
const Foam::IOobject& fieldObject,
const Foam::ensightMesh& eMesh,
const Foam::fileName& postProcPath,
const Foam::word& prepend,
const Foam::label timeIndex,
Foam::Ostream& ensightCaseFile
)
{
Info<< "Converting field " << fieldObject.name() << endl;
word timeFile = prepend + itoa(timeIndex);
const fvMesh& mesh = eMesh.mesh;
const Time& runTime = mesh.time();
const cellSets& meshCellSets = eMesh.meshCellSets;
const List<faceSets>& boundaryFaceSets = eMesh.boundaryFaceSets;
const HashTable<labelList>& allPatchNames = eMesh.allPatchNames;
const HashTable<label>& patchIndices = eMesh.patchIndices;
const wordHashSet& patchNames = eMesh.patchNames;
const HashTable<ensightMesh::nFacePrims>& nPatchPrims = eMesh.nPatchPrims;
const labelList& tets = meshCellSets.tets;
const labelList& pyrs = meshCellSets.pyrs;
const labelList& prisms = meshCellSets.prisms;
const labelList& wedges = meshCellSets.wedges;
const labelList& hexes = meshCellSets.hexes;
const labelList& polys = meshCellSets.polys;
OFstream *ensightFilePtr = NULL;
if (Pstream::master())
{
// set the filename of the ensight file
fileName ensightFileName(timeFile + "." + fieldObject.name());
ensightFilePtr = new OFstream
(
postProcPath/ensightFileName,
runTime.writeFormat(),
runTime.writeVersion(),
runTime.writeCompression()
);
}
OFstream& ensightFile = *ensightFilePtr;
GeometricField<Type, fvPatchField, volMesh> vf(fieldObject, mesh);
if (!patchNames.size())
{
if (Pstream::master())
{
if (timeIndex == 0)
{
ensightCaseFile.setf(ios_base::left);
ensightCaseFile
<< pTraits<Type>::typeName
<< " per element: 1 "
<< setw(15) << vf.name()
<< (' ' + prepend + "***." + vf.name()).c_str()
<< nl;
}
ensightFile
<< pTraits<Type>::typeName << nl
<< "part" << nl
<< setw(10) << 1 << nl;
ensightFile.setf(ios_base::scientific, ios_base::floatfield);
ensightFile.precision(5);
}
if (meshCellSets.nHexesWedges)
{
if (Pstream::master())
{
ensightFile << "hexa8" << nl;
for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
{
writeData
(
map(vf, hexes, wedges, cmpt),
ensightFile
);
for (int slave=1; slave<Pstream::nProcs(); slave++)
{
IPstream fromSlave(Pstream::scheduled, slave);
scalarField data(fromSlave);
writeData(data, ensightFile);
}
}
}
else
{
for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
{
OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
toMaster<< map(vf, hexes, wedges, cmpt);
}
}
}
writeAllData("penta6", vf, prisms, meshCellSets.nPrisms, ensightFile);
writeAllData("pyramid5", vf, pyrs, meshCellSets.nPyrs, ensightFile);
writeAllData("tetra4", vf, tets, meshCellSets.nTets, ensightFile);
writeAllData("nfaced", vf, polys, meshCellSets.nPolys, ensightFile);
}
label ensightPatchi = 2;
for
(
HashTable<labelList>::const_iterator iter = allPatchNames.begin();
iter != allPatchNames.end();
++iter
)
{
const word& patchName = iter.key();
const labelList& patchProcessors = iter();
if (!patchNames.size() || patchNames.found(patchName))
{
if (patchIndices.found(patchName))
{
label patchi = patchIndices.find(patchName)();
if
(
writePatchField
(
vf.boundaryField()[patchi],
patchi,
ensightPatchi,
boundaryFaceSets[patchi],
nPatchPrims.find(patchName)(),
patchProcessors,
ensightFile
)
)
{
ensightPatchi++;
}
}
else if (Pstream::master())
{
faceSets nullFaceSet;
if
(
writePatchField
(
Field<Type>(),
-1,
ensightPatchi,
nullFaceSet,
nPatchPrims.find(patchName)(),
patchProcessors,
ensightFile
)
)
{
ensightPatchi++;
}
}
}
}
if (Pstream::master())
{
delete ensightFilePtr;
}
}
// ************************************************************************* //

79
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.H
View File

@ -1,79 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
InClass
Foam::ensightField
Description
SourceFiles
ensightField.C
\*---------------------------------------------------------------------------*/
#ifndef ensightField_H
#define ensightField_H
#include "ensightMesh.H"
#include "HashSet.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type>
void ensightField
(
const Foam::IOobject& fieldObject,
const Foam::ensightMesh& eMesh,
const Foam::fileName& postProcPath,
const Foam::word& prepend,
const Foam::label timeIndex,
Foam::Ostream& ensightCaseFile
);
template<class Type>
void writePatchField
(
const Foam::word& fieldName,
const Foam::Field<Type>& pf,
const Foam::word& patchName,
const Foam::ensightMesh& eMesh,
const Foam::fileName& postProcPath,
const Foam::word& prepend,
const Foam::label timeIndex,
Foam::Ostream& ensightCaseFile
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "ensightField.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

932
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.C
View File

@ -1,932 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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;
}
}
// ************************************************************************* //

213
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.H
View File

@ -1,213 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
Class
Foam::ensightMesh
Description
SourceFiles
ensightMesh.C
\*---------------------------------------------------------------------------*/
#ifndef ensightMesh_H
#define ensightMesh_H
#include "cellSets.H"
#include "faceSets.H"
#include "HashTable.H"
#include "HashSet.H"
#include "fvMesh.H"
#include "OFstream.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class fvMesh;
class argList;
/*---------------------------------------------------------------------------*\
Class ensightMesh Declaration
\*---------------------------------------------------------------------------*/
class ensightMesh
{
// Private data
// Private Member Functions
//- Disallow default bitwise copy construct
ensightMesh(const ensightMesh&);
//- Disallow default bitwise assignment
void operator=(const ensightMesh&);
void writePoints
(
const scalarField& pointsComponent,
OFstream& ensightGeometryFile
) const;
cellShapeList map
(
const cellShapeList& cellShapes,
const labelList& prims
) const;
cellShapeList map
(
const cellShapeList& cellShapes,
const labelList& hexes,
const labelList& wedges
) const;
void writePrims
(
const cellShapeList& cellShapes,
const label pointOffset,
OFstream& ensightGeometryFile
) const;
void writePolys
(
const labelList& polys,
const cellList& cellFaces,
const faceList& faces,
const label pointOffset,
OFstream& ensightGeometryFile
) const;
void writeAllPrims
(
const char* key,
const label nPrims,
const cellShapeList& cellShapes,
const labelList& pointOffsets,
OFstream& ensightGeometryFile
) const;
void writeFacePrims
(
const char* key,
const faceList& patchFaces,
const label pointOffset,
OFstream& ensightGeometryFile
) const;
faceList map
(
const faceList& patchFaces,
const labelList& prims
) const;
void writeAllFacePrims
(
const char* key,
const labelList& prims,
const label nPrims,
const faceList& patchFaces,
const labelList& pointOffsets,
const labelList& patchProcessors,
OFstream& ensightGeometryFile
) const;
public:
// Public data
const fvMesh& mesh;
cellSets meshCellSets;
List<faceSets> boundaryFaceSets;
HashTable<labelList> allPatchNames;
HashTable<label> patchIndices;
wordHashSet patchNames;
class nFacePrims
{
public:
label nPoints;
label nTris;
label nQuads;
label nPolys;
nFacePrims()
:
nPoints(0),
nTris(0),
nQuads(0),
nPolys(0)
{}
};
HashTable<nFacePrims> nPatchPrims;
// Constructors
//- Construct from fvMesh
ensightMesh(const fvMesh&, const argList& args);
// Destructor
~ensightMesh();
// Member Functions
// Access
// Check
// Edit
// Write
void write
(
const fileName& postProcPath,
const word& prepend,
const label timeIndex,
Ostream& ensightCaseFile
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

93
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightParticlePositions.C
View File

@ -1,93 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
Description
\*---------------------------------------------------------------------------*/
#include "ensightParticlePositions.H"
#include "fvMesh.H"
#include "passiveParticle.H"
#include "Cloud.H"
#include "OFstream.H"
#include "IOmanip.H"
#include "itoa.H"
using namespace Foam;
// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
void ensightParticlePositions
(
const Foam::fvMesh& mesh,
const Foam::fileName& postProcPath,
const Foam::word& timeFile,
const Foam::word& sprayName
)
{
const Time& runTime = mesh.time();
Cloud<passiveParticle> parcels(mesh);
fileName ensightFileName(timeFile + "."+ sprayName);
OFstream ensightFile
(
postProcPath/ensightFileName,
runTime.writeFormat(),
runTime.writeVersion(),
runTime.writeCompression()
);
// Output header
ensightFile
<< "lagrangian " << nl
<< "particle coordinates" << nl;
// Set Format
ensightFile.setf(ios_base::scientific, ios_base::floatfield);
ensightFile.precision(5);
ensightFile << setw(8) << parcels.size() << nl;
label nParcels = 0;
// Output position
for
(
Cloud<passiveParticle>::iterator elmnt = parcels.begin();
elmnt != parcels.end();
++elmnt
)
{
const vector& p = elmnt().position();
ensightFile
<< setw(8) << ++nParcels
<< setw(12) << p.x() << setw(12) << p.y() << setw(12) << p.z()
<< nl;
}
}
// ************************************************************************* //

54
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightParticlePositions.H
View File

@ -1,54 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
InClass
Foam::ensightParticlePositions
Description
SourceFiles
ensightParticlePositions.C
\*---------------------------------------------------------------------------*/
#ifndef ensightParticlePositions_H
#define ensightParticlePositions_H
#include "fvMesh.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
void ensightParticlePositions
(
const Foam::fvMesh& mesh,
const Foam::fileName& postProcPath,
const Foam::word& timeFile,
const Foam::word& sprayName
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

117
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightSprayField.C
View File

@ -1,117 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
Description
\*---------------------------------------------------------------------------*/
#include "ensightSprayField.H"
#include "Time.H"
#include "IOField.H"
#include "OFstream.H"
#include "IOmanip.H"
using namespace Foam;
// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
template<class Type>
void ensightSprayField
(
const Foam::IOobject& fieldObject,
const Foam::fileName& postProcPath,
const Foam::word& prepend,
const Foam::label timeIndex,
const Foam::word& sprayName,
Foam::Ostream& ensightCaseFile
)
{
Info<< "Converting spray field " << fieldObject.name() << endl;
word timeFile = prepend + itoa(timeIndex);
const Time& runTime = fieldObject.time();
if (timeIndex == 0)
{
ensightCaseFile
<< pTraits<Type>::typeName << " per measured node: 1 ";
ensightCaseFile.width(15);
ensightCaseFile.setf(ios_base::left);
ensightCaseFile
<< ("s" + fieldObject.name()).c_str()
<< (' ' + prepend + "***." + sprayName
+ "." + fieldObject.name()).c_str()
<< nl;
}
// set the filename of the ensight file
fileName ensightFileName
(
timeFile + "." + sprayName +"." + fieldObject.name()
);
OFstream ensightFile
(
postProcPath/ensightFileName,
runTime.writeFormat(),
runTime.writeVersion(),
runTime.writeCompression()
);
ensightFile << pTraits<Type>::typeName << " values" << nl;
IOField<Type> vf(fieldObject);
ensightFile.setf(ios_base::scientific, ios_base::floatfield);
ensightFile.precision(5);
label count = 0;
forAll(vf, i)
{
Type v = vf[i];
if (mag(v) < 1.0e-90)
{
v = pTraits<Type>::zero;
}
for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
{
ensightFile << setw(12) << component(v, cmpt);
if (++count % 6 == 0)
{
ensightFile << nl;
}
}
}
if ( (count % 6 != 0) || (count==0) )
{
ensightFile << nl;
}
}
// ************************************************************************* //

64
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightSprayField.H
View File

@ -1,64 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
InClass
Foam::ensightSprayField
Description
SourceFiles
ensightSprayField.C
\*---------------------------------------------------------------------------*/
#ifndef ensightSprayField_H
#define ensightSprayField_H
#include "IOobject.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type>
void ensightSprayField
(
const Foam::IOobject& fieldObject,
const Foam::fileName& postProcPath,
const Foam::word& prepend,
const Foam::label timeIndex,
const Foam::word& timeFile,
const Foam::word& sprayName,
Foam::Ostream& ensightCaseFile
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "ensightSprayField.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

88
applications/utilities/postProcessing/dataConversion/foamToEnsight/faceSets.H
View File

@ -1,88 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
Class
Foam::faceSets
Description
\*---------------------------------------------------------------------------*/
#ifndef faceSets_H
#define faceSets_H
#include "labelList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class faceSets Declaration
\*---------------------------------------------------------------------------*/
class faceSets
{
// Private Member Functions
//- Disallow default bitwise copy construct
faceSets(const faceSets&);
//- Disallow default bitwise assignment
void operator=(const faceSets&);
public:
label nTris;
label nQuads;
label nPolys;
labelList tris;
labelList quads;
labelList polys;
// Constructors
//- Construct null
faceSets()
:
nTris(0),
nQuads(0),
nPolys(0)
{}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

388
applications/utilities/postProcessing/dataConversion/foamToEnsight/foamToEnsight.C
View File

@ -1,388 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
Description
Translates FOAM data to EnSight format
\*---------------------------------------------------------------------------*/
#include "argList.H"
#include "volFields.H"
#include "tensorIOField.H"
#include "IOobjectList.H"
#include "OFstream.H"
#include "IOmanip.H"
#include "scalarIOField.H"
#include "ensightMesh.H"
#include "ensightField.H"
#include "ensightParticlePositions.H"
#include "ensightSprayField.H"
#include "fvc.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
argList::validOptions.insert("patches", "patch list");
# include "addTimeOptions.H"
/*
const label nTypes = 3;
const word fieldTypes[] =
{
volScalarField::typeName,
volVectorField::typeName,
volTensorField::typeName
};
const label nSprayFieldTypes = 3;
const word sprayFieldTypes[] =
{
scalarIOField::typeName,
vectorIOField::typeName,
tensorIOField::typeName
};
*/
const label nTypes = 2;
const word fieldTypes[] =
{
volScalarField::typeName,
volVectorField::typeName
};
const label nSprayFieldTypes = 2;
const word sprayFieldTypes[] =
{
scalarIOField::typeName,
vectorIOField::typeName
};
# include "setRootCase.H"
# include "createTime.H"
// get the available time-steps
instantList Times = runTime.times();
# include "checkTimeOptions.H"
runTime.setTime(Times[startTime], startTime);
# include "createMesh.H"
const word postProcDir = "EnSight";
const word prepend = args.globalCaseName() + '.';
const word sprayName = "lagrangian";
fileName postProcPath = args.rootPath()/args.globalCaseName()/postProcDir;
if (Pstream::master())
{
if (dir(postProcPath))
{
rmDir(postProcPath);
}
mkDir(postProcPath);
}
OFstream *ensightCaseFilePtr = NULL;
if (Pstream::master())
{
// Open the Case file
fileName ensightCaseFileName = prepend + "case";
ensightCaseFilePtr = new OFstream
(
postProcPath/ensightCaseFileName,
runTime.writeFormat(),
runTime.writeVersion(),
runTime.writeCompression()
);
Info<< nl << "Case file is " << ensightCaseFileName << endl;
}
OFstream& ensightCaseFile = *ensightCaseFilePtr;
// Construct the EnSight mesh
ensightMesh eMesh(mesh, args);
// Set Time to the last time before looking for the spray objects
runTime.setTime(Times[Times.size()-1], Times.size()-1);
IOobjectList objects(mesh, runTime.timeName());
IOobjectList sprayObjects(mesh, runTime.timeName(), "lagrangian");
bool lagrangianExist = false;
if (!eMesh.patchNames.size())
{
IOobject lagrangianHeader
(
"positions",
runTime.timeName(),
"lagrangian",
mesh,
IOobject::NO_READ
);
if (lagrangianHeader.headerOk())
{
lagrangianExist = true;
}
}
# include "ensightCaseHeader.H"
# include "checkMeshMoving.H"
word geomCaseFileName = prepend + "000";
if (Pstream::master())
{
// test pre check variable if there is a moving mesh
if (meshMoving == true) geomCaseFileName = prepend + "***";
ensightCaseFile
<< "GEOMETRY" << nl
<< "model: 1 "
<< (geomCaseFileName + ".mesh").c_str() << nl;
}
label nTimeSteps = 0;
for (label n=startTime; n<endTime; n++)
{
nTimeSteps++;
runTime.setTime(Times[n], n);
label timeIndex = n - startTime;
word timeName = itoa(timeIndex);
word timeFile = prepend + timeName;
Info << "Translating time = " << runTime.timeName() << nl;
# include "moveMesh.H"
if (timeIndex == 0 || mesh.moving())
{
eMesh.write
(
postProcPath,
prepend,
timeIndex,
ensightCaseFile
);
}
if (Pstream::master() && timeIndex == 0)
{
if (lagrangianExist)
{
ensightCaseFile
<< (
"measured: 1 "
+ prepend
+ "***."
+ sprayName
).c_str()
<< nl;
}
ensightCaseFile << nl << "VARIABLE" << nl;
}
for (label i=0; i<nTypes; i++)
{
wordList fieldNames = objects.names(fieldTypes[i]);
for (label j=0; j<fieldNames.size(); j++)
{
word fieldName = fieldNames[j];
bool variableGood = true;
# include "checkData.H"
if (variableGood)
{
IOobject fieldObject
(
fieldName,
mesh.time().timeName(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
);
if (fieldTypes[i] == volScalarField::typeName)
{
ensightField<scalar>
(
fieldObject,
eMesh,
postProcPath,
prepend,
timeIndex,
ensightCaseFile
);
}
else if (fieldTypes[i] == volVectorField::typeName)
{
ensightField<vector>
(
fieldObject,
eMesh,
postProcPath,
prepend,
timeIndex,
ensightCaseFile
);
}
else if (fieldTypes[i] == volSphericalTensorField::typeName)
{
ensightField<sphericalTensor>
(
fieldObject,
eMesh,
postProcPath,
prepend,
timeIndex,
ensightCaseFile
);
}
else if (fieldTypes[i] == volSymmTensorField::typeName)
{
ensightField<symmTensor>
(
fieldObject,
eMesh,
postProcPath,
prepend,
timeIndex,
ensightCaseFile
);
}
else if (fieldTypes[i] == volTensorField::typeName)
{
ensightField<tensor>
(
fieldObject,
eMesh,
postProcPath,
prepend,
timeIndex,
ensightCaseFile
);
}
}
}
}
if (lagrangianExist)
{
ensightParticlePositions
(
mesh,
postProcPath,
timeFile,
sprayName
);
for (label i=0; i<nSprayFieldTypes; i++)
{
wordList fieldNames = sprayObjects.names(sprayFieldTypes[i]);
for (label j=0; j<fieldNames.size(); j++)
{
word fieldName = fieldNames[j];
IOobject fieldObject
(
fieldName,
mesh.time().timeName(),
"lagrangian",
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
);
if (sprayFieldTypes[i] == scalarIOField::typeName)
{
ensightSprayField<scalar>
(
fieldObject,
postProcPath,
prepend,
timeIndex,
sprayName,
ensightCaseFile
);
}
else if (sprayFieldTypes[i] == vectorIOField::typeName)
{
ensightSprayField<vector>
(
fieldObject,
postProcPath,
prepend,
timeIndex,
sprayName,
ensightCaseFile
);
}
else if (sprayFieldTypes[i] == tensorIOField::typeName)
{
ensightSprayField<tensor>
(
fieldObject,
postProcPath,
prepend,
timeIndex,
sprayName,
ensightCaseFile
);
}
}
}
}
}
# include "ensightCaseTail.H"
if (Pstream::master())
{
delete ensightCaseFilePtr;
}
return 0;
}
// ************************************************************************* //

64
applications/utilities/postProcessing/dataConversion/foamToEnsight/itoa.C
View File

@ -1,64 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
Description
\*---------------------------------------------------------------------------*/
#include "itoa.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
word itoa(const label n)
{
const label offset = '0';
const label length = 3;
char val[length + 1];
label leftOfN = n;
for (label i=0; i<length; i++)
{
label j = label(leftOfN/pow(10, length - i - 1));
leftOfN -= j*pow(10, length - i - 1);
val[i] = offset + j;
}
val[length] = 0;
return val;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

45
applications/utilities/postProcessing/dataConversion/foamToEnsight/itoa.H
View File

@ -1,45 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
Description
\*---------------------------------------------------------------------------*/
#include "word.H"
#include "label.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
word itoa(const label n);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

28
applications/utilities/postProcessing/dataConversion/foamToEnsight/moveMesh.H
View File

@ -1,28 +0,0 @@
{
IOobject ioPoints
(
"points",
runTime.timeName(),
polyMesh::meshSubDir,
mesh
);
if (ioPoints.headerOk())
{
// Reading new points
pointIOField newPoints
(
IOobject
(
"points",
mesh.time().timeName(),
polyMesh::meshSubDir,
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
);
mesh.movePoints(newPoints);
}
}