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

GIT: Resolved conflicts arising from merge with develop branch

Browse Source
This commit is contained in:
Andrew Heather
2016-09-26 10:57:34 +01:00
parent ad1e798293 ba249f8e76
commit 47eb24bed5
48 changed files with 2484 additions and 1295 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

@ -4,11 +4,13 @@ EXE_INC = \
-I$(LIB_SRC)/dynamicMesh/lnInclude \
-I$(LIB_SRC)/fileFormats/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude \
-I$(LIB_SRC)/lagrangian/basic/lnInclude
-I$(LIB_SRC)/lagrangian/basic/lnInclude \
-I$(LIB_SRC)/conversion/lnInclude
EXE_LIBS = \
-ldynamicMesh \
-lfileFormats \
-lsampling \
-lgenericPatchFields \
-llagrangian
-llagrangian \
-lconversion

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

@ -1,21 +1,33 @@
// ignore special fields or fields that we don't handle
//
bool variableGood = true;
for (label n1=0; n1<Times.size() && variableGood; ++n1)
// ignore special fields (_0 fields),
// ignore fields we don't handle,
// ignore fields that are not available for all time-steps
// hash by field-name in fieldsToUse
if (!fieldsToUse.found(fieldName))
{
// ignore _0 fields
if (fieldName.size() > 2 && fieldName(fieldName.size() - 2, 2) == "_0")
bool variableGood = false;
forAll(timeDirs, n1)
{
variableGood = false;
}
else
{
variableGood = IOobject
variableGood =
(
fieldName,
Times[n1].name(),
mesh,
IOobject::NO_READ
).typeHeaderOk<volScalarField>(false);
fieldName.size() > 2 && fieldName(fieldName.size()-2, 2) == "_0"
? false
: IOobject
(
fieldName,
timeDirs[n1].name(),
mesh,
IOobject::NO_READ
).typeHeaderOk<volScalarField>(false)
);
if (variableGood)
{
break;
}
}
reduce(variableGood, andOp<bool>());
fieldsToUse.set(fieldName, variableGood);
}

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

@ -1,27 +1,50 @@
// check for "points" in any of the result directories
bool meshMoving = false;
if (Times.size() > 1)
if (timeDirs.size() > 1 && Pstream::master())
{
// We already loaded a mesh (usually from constant). See if any other
// points files
forAll(Times, timeI)
// We already loaded a mesh (usually from constant).
// See if any other "polyMesh/points" files exist too.
const fileName& baseDir = mesh.time().path();
Info<< "Search for moving mesh ... " << flush;
forAll(timeDirs, timeI)
{
if (Times[timeI].name() != mesh.pointsInstance())
{
IOobject io
const word& timeName = timeDirs[timeI].name();
meshMoving =
(
timeName != mesh.pointsInstance()
&& isDir(baseDir/timeName/polyMesh::meshSubDir)
&& IOobject
(
"points",
Times[timeI].name(),
timeName,
polyMesh::meshSubDir,
mesh,
IOobject::NO_READ
);
if (io.typeHeaderOk<pointIOField>(true))
{
meshMoving = true;
break;
}
IOobject::NO_READ,
IOobject::NO_WRITE,
false // no register
).typeHeaderOk<pointIOField>(true)
);
if (meshMoving)
{
break;
}
}
if (meshMoving)
{
Info<< "found." << nl
<< " Writing meshes for every timestep." << endl;
}
else
{
Info<< "none detected." << endl;
}
}
reduce(meshMoving, orOp<bool>());

22
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightAsciiStream.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -52,17 +52,17 @@ class ensightAsciiStream
{
// Private data
//- Description of data_
//- Output file stream
OFstream str_;
// Private Member Functions
//- Disallow default bitwise copy construct
ensightAsciiStream(const ensightAsciiStream&);
ensightAsciiStream(const ensightAsciiStream&) = delete;
//- Disallow default bitwise assignment
void operator=(const ensightAsciiStream&);
void operator=(const ensightAsciiStream&) = delete;
public:
@ -70,14 +70,14 @@ public:
// Constructors
//- Construct from components
ensightAsciiStream(const fileName& f, const Time& runTime)
ensightAsciiStream(const fileName& f)
:
ensightStream(f),
str_
(
f,
runTime.writeFormat(),
runTime.writeVersion(),
IOstream::ASCII,
IOstream::currentVersion,
IOstream::UNCOMPRESSED
)
{
@ -139,14 +139,6 @@ public:
<< setw(10) << partI << nl;
}
// Member Operators
// Friend Functions
// Friend Operators
// IOstream Operators
};

21
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightBinaryStream.H
View File

@ -51,17 +51,17 @@ class ensightBinaryStream
{
// Private data
//- Description of data_
//- Output file stream
autoPtr<std::ofstream> str_;
// Private Member Functions
//- Disallow default bitwise copy construct
ensightBinaryStream(const ensightBinaryStream&);
ensightBinaryStream(const ensightBinaryStream&) = delete;
//- Disallow default bitwise assignment
void operator=(const ensightBinaryStream&);
void operator=(const ensightBinaryStream&) = delete;
public:
@ -69,7 +69,7 @@ public:
// Constructors
//- Construct from components
ensightBinaryStream(const fileName& f, const Time&)
ensightBinaryStream(const fileName& f)
:
ensightStream(f),
str_
@ -90,11 +90,6 @@ public:
// Member Functions
virtual bool ascii() const
{
return false;
}
virtual void write(const char* val)
{
char buffer[80];
@ -141,14 +136,6 @@ public:
write(partI);
}
// Member Operators
// Friend Functions
// Friend Operators
// IOstream Operators
};

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

@ -1,5 +1,8 @@
if (Pstream::master())
{
ensightCaseFile.setf(ios_base::scientific, ios_base::floatfield);
ensightCaseFile.precision(5);
ensightCaseFile << nl << "TIME" << nl
<< "time set: " << 1 << nl
<< "number of steps: " << nTimeSteps << nl
@ -8,20 +11,17 @@ if (Pstream::master())
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)
if (timeDirs[0].value() < 0)
{
Tcorr = - Times[0].value();
Tcorr = -timeDirs[0].value();
Info<< "Correcting time values. Adding " << Tcorr << endl;
}
forAll(Times, n)
forAll(timeDirs, n)
{
ensightCaseFile << setw(12) << Times[n].value() + Tcorr << " ";
ensightCaseFile << setw(12) << timeDirs[n].value() + Tcorr << " ";
if (++count % 6 == 0)
{

180
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCloud.C Normal file
View File

@ -0,0 +1,180 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
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 3 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, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "ensightCloud.H"
#include "ensightFile.H"
#include "fvMesh.H"
#include "passiveParticle.H"
#include "Cloud.H"
#include "pointList.H"
// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
void Foam::ensightParticlePositions
(
const fvMesh& mesh,
const fileName& dataDir,
const label timeIndex,
const word& cloudName,
const bool dataExists,
IOstream::streamFormat format
)
{
if (dataExists)
{
Info<< " positions";
}
else
{
Info<< " positions{0}";
}
// Total number of parcels on all processes
label nTotParcels = 0;
autoPtr<Cloud<passiveParticle>> cloudPtr;
if (dataExists)
{
cloudPtr.reset(new Cloud<passiveParticle>(mesh, cloudName, false));
nTotParcels = cloudPtr().size();
}
reduce(nTotParcels, sumOp<label>());
if (Pstream::master())
{
const fileName postFileName =
ensightFile::subDir(timeIndex)/cloud::prefix/cloudName/"positions";
// the ITER/lagrangian subdirectory must exist
mkDir(dataDir/postFileName.path());
ensightFile os(dataDir, postFileName, format);
// tag binary format (just like geometry files)
os.writeBinaryHeader();
os.write(postFileName); // description
os.newline();
os.write("particle coordinates");
os.newline();
os.write(nTotParcels, 8); // unusual width
os.newline();
if (!nTotParcels)
{
return; // DONE
}
if (format == IOstream::BINARY)
{
// binary write is Ensight6 - first ids, then positions
// 1-index
for (label parcelId = 0; parcelId < nTotParcels; ++parcelId)
{
os.write(parcelId+1);
}
// Master
forAllConstIter(Cloud<passiveParticle>, cloudPtr(), elmnt)
{
const point& p = elmnt().position();
os.write(p.x());
os.write(p.y());
os.write(p.z());
}
// Slaves
for (int slave=1; slave<Pstream::nProcs(); ++slave)
{
IPstream fromSlave(Pstream::scheduled, slave);
pointList points(fromSlave);
forAll(points, pti)
{
const point& p = points[pti];
os.write(p.x());
os.write(p.y());
os.write(p.z());
}
}
}
else
{
// ASCII id + position together
label parcelId = 0;
forAllConstIter(Cloud<passiveParticle>, cloudPtr(), elmnt)
{
const point& p = elmnt().position();
os.write(++parcelId, 8); // unusual width
os.write(p.x());
os.write(p.y());
os.write(p.z());
os.newline();
}
// Slaves
for (int slave=1; slave<Pstream::nProcs(); ++slave)
{
IPstream fromSlave(Pstream::scheduled, slave);
pointList points(fromSlave);
forAll(points, pti)
{
const point& p = points[pti];
os.write(++parcelId, 8); // unusual width
os.write(p.x());
os.write(p.y());
os.write(p.z());
os.newline();
}
}
}
}
else if (nTotParcels)
{
// SLAVE, and data exist
pointList points(cloudPtr().size());
label pti = 0;
forAllConstIter(Cloud<passiveParticle>, cloudPtr(), elmnt)
{
const point& p = elmnt().position();
points[pti++] = p;
}
{
OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
toMaster<< points;
}
}
}
// ************************************************************************* //

45
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCloudField.H → applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCloud.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -27,35 +27,62 @@ InApplication
Description
SourceFiles
ensightCloudField.C
ensightCloud.C
ensightCloudTemplates.C
\*---------------------------------------------------------------------------*/
#ifndef ensightCloudField_H
#define ensightCloudField_H
#ifndef ensightCloud_H
#define ensightCloud_H
#include "ensightFile.H"
#include "fvMesh.H"
#include "Cloud.H"
#include "IOobject.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
void ensightParticlePositions
(
const fvMesh& mesh,
const fileName& dataDir,
const label timeIndex,
const word& cloudName,
const bool dataExists,
const IOstream::streamFormat format
);
template<class Type>
void ensightCloudField
(
const IOobject& fieldObject,
const fileName& postProcPath,
const word& prepend,
const fileName& dataDir,
const label timeIndex,
const word& timeFile,
const word& cloudName,
const label cloudNo,
Ostream& ensightCaseFile,
const bool dataExists
const bool dataExists,
const IOstream::streamFormat format
);
template<class Type>
void writeCloudField
(
const IOField<Type>& field,
ensightFile& os
);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "ensightCloudField.C"
#include "ensightCloudTemplates.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

129
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCloudField.C
View File

@ -1,129 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "ensightCloudField.H"
#include "Time.H"
#include "IOField.H"
#include "OFstream.H"
#include "IOmanip.H"
#include "ensightPTraits.H"
using namespace Foam;
// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
template<class Type>
void ensightCloudField
(
const IOobject& fieldObject,
const fileName& postProcPath,
const word& prepend,
const label timeIndex,
const word& cloudName,
Ostream& ensightCaseFile,
const bool dataExists
)
{
if (dataExists)
{
Info<< "Converting cloud " << cloudName
<< " field " << fieldObject.name() << endl;
}
else
{
Info<< "Creating empty cloud " << cloudName
<< " field " << fieldObject.name() << endl;
}
word timeFile = prepend + itoa(timeIndex);
const Time& runTime = fieldObject.time();
if (timeIndex == 0 && Pstream::master())
{
ensightCaseFile
<< pTraits<Type>::typeName << " per measured node: 1 ";
ensightCaseFile.width(15);
ensightCaseFile.setf(ios_base::left);
ensightCaseFile
<< ("c" + fieldObject.name()).c_str()
<< (' ' + prepend + "****." + cloudName
+ "." + fieldObject.name()).c_str()
<< nl;
}
fileName ensightFileName
(
timeFile + "." + cloudName +"." + fieldObject.name()
);
OFstream ensightFile
(
postProcPath/ensightFileName,
runTime.writeFormat(),
runTime.writeVersion(),
runTime.writeCompression()
);
ensightFile<< pTraits<Type>::typeName << " values" << nl;
if (dataExists)
{
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 = Zero;
}
for (direction i=0; i < pTraits<Type>::nComponents; ++i)
{
label cmpt = ensightPTraits<Type>::componentOrder[i];
ensightFile << setw(12) << component(v, cmpt);
if (++count % 6 == 0)
{
ensightFile << nl;
}
}
}
if ((count % 6 != 0) || (count==0))
{
ensightFile << nl;
}
}
}
// ************************************************************************* //

192
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCloudTemplates.C Normal file
View File

@ -0,0 +1,192 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
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 3 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, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "ensightCloud.H"
#include "ensightFile.H"
#include "Time.H"
#include "IOField.H"
#include "OFstream.H"
#include "IOmanip.H"
#include "ensightPTraits.H"
// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
template<class Type>
void Foam::writeCloudField
(
const Foam::IOField<Type>& field,
Foam::ensightFile& os
)
{
if (returnReduce(field.size(), sumOp<label>()) > 0)
{
if (Pstream::master())
{
// 6 values per line
label count = 0;
// Master
forAll(field, i)
{
Type val = field[i];
if (mag(val) < 1e-90)
{
val = Zero;
}
for (direction d=0; d < pTraits<Type>::nComponents; ++d)
{
label cmpt = ensightPTraits<Type>::componentOrder[d];
os.write(component(val, cmpt));
if (++count % 6 == 0)
{
os.newline();
}
}
}
// Slaves
for (int slave=1; slave<Pstream::nProcs(); ++slave)
{
IPstream fromSlave(Pstream::scheduled, slave);
Field<Type> slaveData(fromSlave);
forAll(slaveData, i)
{
Type val = slaveData[i];
if (mag(val) < 1e-90)
{
val = Zero;
}
for (direction d=0; d < pTraits<Type>::nComponents; ++d)
{
label cmpt = ensightPTraits<Type>::componentOrder[d];
os.write(component(val, cmpt));
if (++count % 6 == 0)
{
os.newline();
}
}
}
}
// add final newline if required
if (count % 6)
{
os.newline();
}
}
else
{
OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
toMaster<< field;
}
}
}
template<class Type>
void Foam::ensightCloudField
(
const Foam::IOobject& fieldObject,
const Foam::fileName& dataDir,
const Foam::label timeIndex,
const Foam::word& cloudName,
const Foam::label cloudNo,
Foam::Ostream& ensightCaseFile,
const bool dataExists,
Foam::IOstream::streamFormat format
)
{
const ensight::VarName varName(fieldObject.name());
if (dataExists)
{
Info<< ' ' << fieldObject.name();
}
else
{
Info<< ' ' << fieldObject.name() << "{0}"; // ie, empty field
}
ensightFile* filePtr(nullptr);
if (Pstream::master())
{
const fileName postFileName =
ensightFile::subDir(timeIndex)/cloud::prefix/cloudName/varName;
// the ITER/lagrangian subdirectory must exist
// the ITER/lagrangian subdirectory was already created
// when writing positions
mkDir(dataDir/postFileName.path());
if (timeIndex == 0)
{
const fileName dirName =
dataDir.name()/ensightFile::mask()/cloud::prefix/cloudName;
ensightCaseFile.setf(ios_base::left);
// prefix variables with 'c' (cloud)
ensightCaseFile
<< ensightPTraits<Type>::typeName << " per "
<< setw(20)
<< "measured node:"
<< " 1 "
<< setw(15)
<< ("c" + Foam::name(cloudNo) + varName).c_str() << ' '
<< (dirName/varName).c_str()
<< nl;
}
filePtr = new ensightFile(dataDir, postFileName, format);
// description
filePtr->write
(
string(postFileName + " <" + pTraits<Type>::typeName + ">")
);
filePtr->newline();
}
if (dataExists)
{
IOField<Type> field(fieldObject);
writeCloudField(field, *filePtr);
}
if (filePtr) // on master only
{
delete filePtr;
}
}
// ************************************************************************* //

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

@ -23,12 +23,12 @@ License
\*---------------------------------------------------------------------------*/
#include "ensightFile.H"
#include "ensightField.H"
#include "fvMesh.H"
#include "volFields.H"
#include "OFstream.H"
#include "IOmanip.H"
#include "itoa.H"
#include "volPointInterpolation.H"
#include "ensightBinaryStream.H"
#include "ensightAsciiStream.H"
@ -76,7 +76,9 @@ volField
// Construct volField (with zeroGradient) from dimensioned field
IOobject io(df);
io.readOpt() = IOobject::NO_READ;
io.readOpt() = IOobject::NO_READ;
io.writeOpt() = IOobject::NO_WRITE;
io.registerObject() = false;
tmp<GeometricField<Type, fvPatchField, volMesh>> tvf
(
@ -84,16 +86,17 @@ volField
(
io,
df.mesh(),
df.dimensions(),
zeroGradientFvPatchField<scalar>::typeName
dimensioned<Type>("0", df.dimensions(), Zero),
zeroGradientFvPatchField<Type>::typeName
)
);
tvf.ref().primitiveFieldRef() = df;
tvf.ref().correctBoundaryConditions();
const GeometricField<Type, fvPatchField, volMesh>& vf = tvf();
if (meshSubsetter.hasSubMesh())
{
const GeometricField<Type, fvPatchField, volMesh>& vf = tvf();
tmp<GeometricField<Type, fvPatchField, volMesh>> tfld
(
meshSubsetter.interpolate(vf)
@ -116,10 +119,8 @@ volField
// const IOobject& io,
// const fvMesh& mesh,
// const ensightMesh& eMesh,
// const fileName& postProcPath,
// const word& prepend,
// const fileName& dataDir,
// const label timeIndex,
// const bool binary,
// const bool nodeValues,
// Ostream& ensightCaseFile
//)
@ -129,10 +130,8 @@ volField
// (
// volField<typename Container::value_type>(meshSubsetter, fld),
// eMesh,
// postProcPath,
// prepend,
// dataDir,
// timeIndex,
// binary,
// nodeValues,
// ensightCaseFile
// );
@ -170,26 +169,26 @@ void writeField
(
const char* key,
const Field<Type>& vf,
ensightStream& ensightFile
ensightStream& os
)
{
if (returnReduce(vf.size(), sumOp<label>()) > 0)
{
if (Pstream::master())
{
ensightFile.write(key);
os.write(key);
for (direction i=0; i < pTraits<Type>::nComponents; ++i)
{
label cmpt = ensightPTraits<Type>::componentOrder[i];
ensightFile.write(vf.component(cmpt));
os.write(vf.component(cmpt));
for (int slave=1; slave<Pstream::nProcs(); slave++)
{
IPstream fromSlave(Pstream::scheduled, slave);
scalarField slaveData(fromSlave);
ensightFile.write(slaveData);
os.write(slaveData);
}
}
}
@ -215,35 +214,35 @@ bool writePatchField
const label ensightPatchi,
const faceSets& boundaryFaceSet,
const ensightMesh::nFacePrimitives& nfp,
ensightStream& ensightFile
ensightStream& os
)
{
if (nfp.nTris || nfp.nQuads || nfp.nPolys)
{
if (Pstream::master())
{
ensightFile.writePartHeader(ensightPatchi);
os.writePartHeader(ensightPatchi);
}
writeField
(
"tria3",
Field<Type>(pf, boundaryFaceSet.tris),
ensightFile
os
);
writeField
(
"quad4",
Field<Type>(pf, boundaryFaceSet.quads),
ensightFile
os
);
writeField
(
"nsided",
Field<Type>(pf, boundaryFaceSet.polys),
ensightFile
os
);
return true;
@ -262,15 +261,11 @@ void writePatchField
const Field<Type>& pf,
const word& patchName,
const ensightMesh& eMesh,
const fileName& postProcPath,
const word& prepend,
const fileName& dataDir,
const label timeIndex,
const bool binary,
Ostream& ensightCaseFile
)
{
const Time& runTime = eMesh.mesh().time();
const List<faceSets>& boundaryFaceSets = eMesh.boundaryFaceSets();
const wordList& allPatchNames = eMesh.allPatchNames();
const HashTable<ensightMesh::nFacePrimitives>&
@ -290,53 +285,51 @@ void writePatchField
ensightPatchi++;
}
word pfName = patchName + '.' + fieldName;
word timeFile = prepend + itoa(timeIndex);
ensightStream* ensightFilePtr = nullptr;
ensightStream* filePtr(nullptr);
if (Pstream::master())
{
// TODO: verify that these are indeed valid ensight variable names
const word varName = patchName + '.' + fieldName;
const fileName postFileName = ensightFile::subDir(timeIndex)/varName;
// the data/ITER subdirectory must exist
mkDir(dataDir/postFileName.path());
if (timeIndex == 0)
{
ensightCaseFile.setf(ios_base::left);
const fileName dirName = dataDir.name()/ensightFile::mask();
ensightCaseFile.setf(ios_base::left);
ensightCaseFile
<< ensightPTraits<Type>::typeName
<< " per element: 1 "
<< setw(15) << pfName
<< (' ' + prepend + "****." + pfName).c_str()
<< ensightPTraits<Type>::typeName << " per "
<< setw(20)
<< "element:"
<< " 1 "
<< setw(15)
<< varName.c_str() << ' '
<< (dirName/varName).c_str()
<< nl;
}
// set the filename of the ensight file
fileName ensightFileName(timeFile + "." + pfName);
if (binary)
if (eMesh.format() == IOstream::BINARY)
{
ensightFilePtr = new ensightBinaryStream
filePtr = new ensightBinaryStream
(
postProcPath/ensightFileName,
runTime
dataDir/postFileName
);
}
else
{
ensightFilePtr = new ensightAsciiStream
filePtr = new ensightAsciiStream
(
postProcPath/ensightFileName,
runTime
dataDir/postFileName
);
}
filePtr->write(ensightPTraits<Type>::typeName);
}
ensightStream& ensightFile = *ensightFilePtr;
if (Pstream::master())
{
ensightFile.write(ensightPTraits<Type>::typeName);
}
ensightStream& os = *filePtr;
if (patchi >= 0)
{
@ -347,7 +340,7 @@ void writePatchField
ensightPatchi,
boundaryFaceSets[patchi],
nPatchPrims.find(patchName)(),
ensightFile
os
);
}
else
@ -361,13 +354,13 @@ void writePatchField
ensightPatchi,
nullFaceSets,
nPatchPrims.find(patchName)(),
ensightFile
os
);
}
if (Pstream::master())
if (filePtr) // on master only
{
delete ensightFilePtr;
delete filePtr;
}
}
@ -377,19 +370,14 @@ void ensightField
(
const GeometricField<Type, fvPatchField, volMesh>& vf,
const ensightMesh& eMesh,
const fileName& postProcPath,
const word& prepend,
const fileName& dataDir,
const label timeIndex,
const bool binary,
Ostream& ensightCaseFile
)
{
Info<< "Converting field " << vf.name() << endl;
word timeFile = prepend + itoa(timeIndex);
Info<< ' ' << vf.name();
const fvMesh& mesh = eMesh.mesh();
const Time& runTime = mesh.time();
const cellSets& meshCellSets = eMesh.meshCellSets();
const List<faceSets>& boundaryFaceSets = eMesh.boundaryFaceSets();
@ -409,48 +397,48 @@ void ensightField
const labelList& hexes = meshCellSets.hexes;
const labelList& polys = meshCellSets.polys;
ensightStream* ensightFilePtr = nullptr;
ensightStream* filePtr(nullptr);
if (Pstream::master())
{
// set the filename of the ensight file
fileName ensightFileName(timeFile + "." + vf.name());
const ensight::VarName varName(vf.name());
const fileName postFileName = ensightFile::subDir(timeIndex)/varName;
if (binary)
// the data/ITER subdirectory must exist
mkDir(dataDir/postFileName.path());
if (timeIndex == 0)
{
ensightFilePtr = new ensightBinaryStream
const fileName dirName = dataDir.name()/ensightFile::mask();
ensightCaseFile.setf(ios_base::left);
ensightCaseFile
<< ensightPTraits<Type>::typeName
<< " per element: 1 "
<< setw(15)
<< varName.c_str() << ' '
<< (dirName/varName).c_str()
<< nl;
}
if (eMesh.format() == IOstream::BINARY)
{
filePtr = new ensightBinaryStream
(
postProcPath/ensightFileName,
runTime
dataDir/postFileName
);
}
else
{
ensightFilePtr = new ensightAsciiStream
filePtr = new ensightAsciiStream
(
postProcPath/ensightFileName,
runTime
dataDir/postFileName
);
}
filePtr->write(ensightPTraits<Type>::typeName);
}
ensightStream& ensightFile = *ensightFilePtr;
if (Pstream::master())
{
if (timeIndex == 0)
{
ensightCaseFile.setf(ios_base::left);
ensightCaseFile
<< ensightPTraits<Type>::typeName
<< " per element: 1 "
<< setw(15) << vf.name()
<< (' ' + prepend + "****." + vf.name()).c_str()
<< nl;
}
ensightFile.write(ensightPTraits<Type>::typeName);
}
ensightStream& os = *filePtr;
if (patchNames.empty())
{
@ -458,42 +446,42 @@ void ensightField
if (Pstream::master())
{
ensightFile.writePartHeader(1);
os.writePartHeader(1);
}
writeField
(
"hexa8",
map(vf, hexes, wedges),
ensightFile
os
);
writeField
(
"penta6",
Field<Type>(vf, prisms),
ensightFile
os
);
writeField
(
"pyramid5",
Field<Type>(vf, pyrs),
ensightFile
os
);
writeField
(
"tetra4",
Field<Type>(vf, tets),
ensightFile
os
);
writeField
(
"nfaced",
Field<Type>(vf, polys),
ensightFile
os
);
}
@ -516,7 +504,7 @@ void ensightField
ensightPatchi,
boundaryFaceSets[patchi],
nPatchPrims.find(patchName)(),
ensightFile
os
)
)
{
@ -541,8 +529,7 @@ void ensightField
eMesh.barrier();
label zoneID = mesh.faceZones().findZoneID(faceZoneName);
const label zoneID = mesh.faceZones().findZoneID(faceZoneName);
const faceZone& fz = mesh.faceZones()[zoneID];
// Prepare data to write
@ -590,7 +577,7 @@ void ensightField
ensightPatchi,
faceZoneFaceSets[zoneID],
nFaceZonePrims.find(faceZoneName)(),
ensightFile
os
)
)
{
@ -598,9 +585,10 @@ void ensightField
}
}
}
if (Pstream::master())
if (filePtr) // on master only
{
delete ensightFilePtr;
delete filePtr;
}
}
@ -610,65 +598,63 @@ void ensightPointField
(
const GeometricField<Type, pointPatchField, pointMesh>& pf,
const ensightMesh& eMesh,
const fileName& postProcPath,
const word& prepend,
const fileName& dataDir,
const label timeIndex,
const bool binary,
Ostream& ensightCaseFile
)
{
Info<< "Converting field " << pf.name() << endl;
word timeFile = prepend + itoa(timeIndex);
Info<< ' ' << pf.name();
const fvMesh& mesh = eMesh.mesh();
const wordList& allPatchNames = eMesh.allPatchNames();
const wordHashSet& patchNames = eMesh.patchNames();
const wordHashSet& faceZoneNames = eMesh.faceZoneNames();
ensightStream* ensightFilePtr = nullptr;
ensightStream* filePtr(nullptr);
if (Pstream::master())
{
// set the filename of the ensight file
fileName ensightFileName(timeFile + "." + pf.name());
const ensight::VarName varName(pf.name());
const fileName postFileName = ensightFile::subDir(timeIndex)/varName;
if (binary)
// the data/ITER subdirectory must exist
mkDir(dataDir/postFileName.path());
if (timeIndex == 0)
{
ensightFilePtr = new ensightBinaryStream
const fileName dirName = dataDir.name()/ensightFile::mask();
ensightCaseFile.setf(ios_base::left);
ensightCaseFile
<< ensightPTraits<Type>::typeName
<< " per "
<< setw(20)
<< " node:"
<< " 1 "
<< setw(15)
<< varName.c_str() << ' '
<< (dirName/varName).c_str()
<< nl;
}
if (eMesh.format() == IOstream::BINARY)
{
filePtr = new ensightBinaryStream
(
postProcPath/ensightFileName,
mesh.time()
dataDir/postFileName
);
}
else
{
ensightFilePtr = new ensightAsciiStream
filePtr = new ensightAsciiStream
(
postProcPath/ensightFileName,
mesh.time()
dataDir/postFileName
);
}
filePtr->write(ensightPTraits<Type>::typeName);
}
ensightStream& ensightFile = *ensightFilePtr;
if (Pstream::master())
{
if (timeIndex == 0)
{
ensightCaseFile.setf(ios_base::left);
ensightCaseFile
<< ensightPTraits<Type>::typeName
<< " per node: 1 "
<< setw(15) << pf.name()
<< (' ' + prepend + "****." + pf.name()).c_str()
<< nl;
}
ensightFile.write(ensightPTraits<Type>::typeName);
}
ensightStream& os = *filePtr;
if (eMesh.patchNames().empty())
{
@ -676,14 +662,14 @@ void ensightPointField
if (Pstream::master())
{
ensightFile.writePartHeader(1);
os.writePartHeader(1);
}
writeField
(
"coordinates",
Field<Type>(pf.primitiveField(), eMesh.uniquePointMap()),
ensightFile
os
);
}
@ -699,11 +685,8 @@ void ensightPointField
if (patchNames.empty() || patchNames.found(patchName))
{
const fvPatch& p = mesh.boundary()[patchi];
if
(
returnReduce(p.size(), sumOp<label>())
> 0
)
if (returnReduce(p.size(), sumOp<label>()) > 0)
{
// Renumber the patch points/faces into unique points
labelList pointToGlobal;
@ -719,14 +702,14 @@ void ensightPointField
if (Pstream::master())
{
ensightFile.writePartHeader(ensightPatchi);
os.writePartHeader(ensightPatchi);
}
writeField
(
"coordinates",
Field<Type>(pf.primitiveField(), uniqueMeshPointLabels),
ensightFile
os
);
ensightPatchi++;
@ -743,8 +726,7 @@ void ensightPointField
eMesh.barrier();
label zoneID = mesh.faceZones().findZoneID(faceZoneName);
const label zoneID = mesh.faceZones().findZoneID(faceZoneName);
const faceZone& fz = mesh.faceZones()[zoneID];
if (returnReduce(fz().nPoints(), sumOp<label>()) > 0)
@ -753,17 +735,17 @@ void ensightPointField
labelList pointToGlobal;
labelList uniqueMeshPointLabels;
autoPtr<globalIndex> globalPointsPtr =
mesh.globalData().mergePoints
(
fz().meshPoints(),
fz().meshPointMap(),
pointToGlobal,
uniqueMeshPointLabels
);
mesh.globalData().mergePoints
(
fz().meshPoints(),
fz().meshPointMap(),
pointToGlobal,
uniqueMeshPointLabels
);
if (Pstream::master())
{
ensightFile.writePartHeader(ensightPatchi);
os.writePartHeader(ensightPatchi);
}
writeField
@ -774,7 +756,7 @@ void ensightPointField
pf.primitiveField(),
uniqueMeshPointLabels
),
ensightFile
os
);
ensightPatchi++;
@ -782,9 +764,9 @@ void ensightPointField
}
}
if (Pstream::master())
if (filePtr) // on master only
{
delete ensightFilePtr;
delete filePtr;
}
}
@ -794,10 +776,8 @@ void ensightField
(
const GeometricField<Type, fvPatchField, volMesh>& vf,
const ensightMesh& eMesh,
const fileName& postProcPath,
const word& prepend,
const fileName& dataDir,
const label timeIndex,
const bool binary,
const bool nodeValues,
Ostream& ensightCaseFile
)
@ -814,10 +794,8 @@ void ensightField
(
pfld,
eMesh,
postProcPath,
prepend,
dataDir,
timeIndex,
binary,
ensightCaseFile
);
}
@ -827,10 +805,8 @@ void ensightField
(
vf,
eMesh,
postProcPath,
prepend,
dataDir,
timeIndex,
binary,
ensightCaseFile
);
}

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

@ -69,10 +69,8 @@ void ensightField
(
const Foam::GeometricField<Type, Foam::fvPatchField, Foam::volMesh>& vf,
const Foam::ensightMesh& eMesh,
const Foam::fileName& postProcPath,
const Foam::word& prepend,
const Foam::fileName& dataDir,
const Foam::label timeIndex,
const bool binary,
const bool nodeValues,
Foam::Ostream& ensightCaseFile
);
@ -85,8 +83,7 @@ void writePatchField
const Foam::Field<Type>& pf,
const Foam::word& patchName,
const Foam::ensightMesh& eMesh,
const Foam::fileName& postProcPath,
const Foam::word& prepend,
const Foam::fileName& dataDir,
const Foam::label timeIndex,
Foam::Ostream& ensightCaseFile
);

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

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -32,16 +32,21 @@ License
#include "processorPolyPatch.H"
#include "cellModeller.H"
#include "IOmanip.H"
#include "itoa.H"
#include "globalIndex.H"
#include "mapDistribute.H"
#include "stringListOps.H"
#include "ensightFile.H"
#include "ensightBinaryStream.H"
#include "ensightAsciiStream.H"
#include <fstream>
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
const char* Foam::ensightMesh::geometryName = "geometry";
// * * * * * * * * * * * * * Private Functions * * * * * * * * * * * * * * //
void Foam::ensightMesh::correct()
@ -403,7 +408,7 @@ Foam::ensightMesh::ensightMesh
const bool faceZones,
const wordReList& faceZonePatterns,
const bool binary
const IOstream::streamFormat format
)
:
mesh_(mesh),
@ -412,7 +417,7 @@ Foam::ensightMesh::ensightMesh
patchPatterns_(patchPatterns),
faceZones_(faceZones),
faceZonePatterns_(faceZonePatterns),
binary_(binary),
format_(format),
meshCellSets_(mesh.nCells())
{
correct();
@ -521,7 +526,7 @@ void Foam::ensightMesh::writePrims
// Create a temp int array
if (cellShapes.size())
{
if (ensightGeometryFile.ascii())
if (format_ == IOstream::ASCII)
{
// Workaround for paraview issue : write one cell per line
@ -1018,63 +1023,56 @@ void Foam::ensightMesh::writeAllPoints
void Foam::ensightMesh::write
(
const fileName& postProcPath,
const word& prepend,
const fileName& dataDir,
const label timeIndex,
const bool meshMoving,
Ostream& ensightCaseFile
) const
{
const Time& runTime = mesh_.time();
const cellShapeList& cellShapes = mesh_.cellShapes();
word timeFile = prepend;
if (timeIndex == 0)
{
timeFile += "0000.";
}
else if (meshMoving)
{
timeFile += itoa(timeIndex) + '.';
}
// set the filename of the ensight file
fileName ensightGeometryFileName = timeFile + "mesh";
ensightStream* ensightGeometryFilePtr = nullptr;
ensightStream* filePtr(nullptr);
if (Pstream::master())
{
if (binary_)
// set the filename of the ensight file
fileName geoFileName = dataDir.path()/ensightMesh::geometryName;
if (meshMoving)
{
ensightGeometryFilePtr = new ensightBinaryStream
geoFileName =
dataDir/ensightFile::subDir(timeIndex)
/ensightMesh::geometryName;
mkDir(geoFileName.path());
}
if (format_ == IOstream::BINARY)
{
filePtr = new ensightBinaryStream
(
postProcPath/ensightGeometryFileName,
runTime
geoFileName
);
ensightGeometryFilePtr->write("C binary");
filePtr->write("C binary");
}
else
{
ensightGeometryFilePtr = new ensightAsciiStream
filePtr = new ensightAsciiStream
(
postProcPath/ensightGeometryFileName,
runTime
geoFileName
);
}
}
ensightStream& ensightGeometryFile = *ensightGeometryFilePtr;
ensightStream& os = *filePtr;
if (Pstream::master())
{
string desc = string("written by OpenFOAM-") + Foam::FOAMversion;
ensightGeometryFile.write("EnSight Geometry File");
ensightGeometryFile.write(desc.c_str());
ensightGeometryFile.write("node id assign");
ensightGeometryFile.write("element id assign");
os.write("EnSight Geometry File");
os.write(desc.c_str());
os.write("node id assign");
os.write("element id assign");
}
if (patchNames_.empty())
@ -1089,7 +1087,7 @@ void Foam::ensightMesh::write
"internalMesh",
uniquePoints,
nPoints,
ensightGeometryFile
os
);
writeAllPrims
@ -1103,7 +1101,7 @@ void Foam::ensightMesh::write
meshCellSets_.wedges,
pointToGlobal_
),
ensightGeometryFile
os
);
writeAllPrims
@ -1111,7 +1109,7 @@ void Foam::ensightMesh::write
"penta6",
meshCellSets_.nPrisms,
map(cellShapes, meshCellSets_.prisms, pointToGlobal_),
ensightGeometryFile
os
);
writeAllPrims
@ -1119,7 +1117,7 @@ void Foam::ensightMesh::write
"pyramid5",
meshCellSets_.nPyrs,
map(cellShapes, meshCellSets_.pyrs, pointToGlobal_),
ensightGeometryFile
os
);
writeAllPrims
@ -1127,13 +1125,13 @@ void Foam::ensightMesh::write
"tetra4",
meshCellSets_.nTets,
map(cellShapes, meshCellSets_.tets, pointToGlobal_),
ensightGeometryFile
os
);
writeAllPolys
(
pointToGlobal_,
ensightGeometryFile
os
);
}
@ -1182,7 +1180,7 @@ void Foam::ensightMesh::write
patchName,
uniquePoints,
globalPointsPtr().size(),
ensightGeometryFile
os
);
writeAllFacePrims
@ -1191,7 +1189,7 @@ void Foam::ensightMesh::write
tris,
nfp.nTris,
patchFaces,
ensightGeometryFile
os
);
writeAllFacePrims
@ -1200,7 +1198,7 @@ void Foam::ensightMesh::write
quads,
nfp.nQuads,
patchFaces,
ensightGeometryFile
os
);
writeAllNSided
@ -1208,7 +1206,7 @@ void Foam::ensightMesh::write
polys,
nfp.nPolys,
patchFaces,
ensightGeometryFile
os
);
}
}
@ -1287,7 +1285,7 @@ void Foam::ensightMesh::write
faceZoneName,
uniquePoints,
globalPointsPtr().size(),
ensightGeometryFile
os
);
writeAllFacePrims
@ -1296,7 +1294,7 @@ void Foam::ensightMesh::write
tris,
nfp.nTris,
faceZoneMasterFaces,
ensightGeometryFile
os
);
writeAllFacePrims
@ -1305,7 +1303,7 @@ void Foam::ensightMesh::write
quads,
nfp.nQuads,
faceZoneMasterFaces,
ensightGeometryFile
os
);
writeAllNSided
@ -1313,14 +1311,14 @@ void Foam::ensightMesh::write
polys,
nfp.nPolys,
faceZoneMasterFaces,
ensightGeometryFile
os
);
}
}
if (Pstream::master())
if (filePtr) // only on master
{
delete ensightGeometryFilePtr;
delete filePtr;
}
}

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

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -57,12 +57,17 @@ class globalIndex;
class ensightStream;
/*---------------------------------------------------------------------------*\
Class ensightMesh Declaration
Class ensightMesh Declaration
\*---------------------------------------------------------------------------*/
class ensightMesh
{
public:
//- The name for geometry files
static const char* geometryName;
//- Helper class for managing face primitives
class nFacePrimitives
{
public:
@ -97,8 +102,8 @@ private:
const bool faceZones_;
const wordReList faceZonePatterns_;
//- Set binary file output
const bool binary_;
//- Ascii/Binary file output
const IOstream::streamFormat format_;
//- The ensight part id for the first patch
label patchPartOffset_;
@ -140,10 +145,10 @@ private:
// Private Member Functions
//- Disallow default bitwise copy construct
ensightMesh(const ensightMesh&);
ensightMesh(const ensightMesh&) = delete;
//- Disallow default bitwise assignment
void operator=(const ensightMesh&);
void operator=(const ensightMesh&) = delete;
void writePoints
(
@ -267,7 +272,7 @@ public:
const wordReList& patchPatterns,
const bool faceZones,
const wordReList& faceZonePatterns,
const bool binary
const IOstream::streamFormat format = IOstream::BINARY
);
@ -284,6 +289,11 @@ public:
return mesh_;
}
IOstream::streamFormat format() const
{
return format_;
}
const cellSets& meshCellSets() const
{
return meshCellSets_;
@ -352,8 +362,6 @@ public:
}
// Other
//- Update for new mesh
@ -371,13 +379,11 @@ public:
void write
(
const fileName& postProcPath,
const word& prepend,
const fileName& ensightDir,
const label timeIndex,
const bool meshMoving,
Ostream& ensightCaseFile
) const;
};

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

@ -1,103 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#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 fvMesh& mesh,
const fileName& postProcPath,
const word& timeFile,
const word& cloudName,
const bool dataExists
)
{
if (dataExists)
{
Info<< "Converting cloud " << cloudName << " positions" << endl;
}
else
{
Info<< "Creating empty cloud " << cloudName << " positions" << endl;
}
const Time& runTime = mesh.time();
fileName ensightFileName(timeFile + "." + cloudName);
OFstream ensightFile
(
postProcPath/ensightFileName,
runTime.writeFormat(),
runTime.writeVersion(),
runTime.writeCompression()
);
// Output header
ensightFile
<< cloudName.c_str() << nl
<< "particle coordinates" << nl;
if (dataExists)
{
Cloud<passiveParticle> parcels(mesh, cloudName, false);
// Set Format
ensightFile.setf(ios_base::scientific, ios_base::floatfield);
ensightFile.precision(5);
ensightFile<< setw(8) << parcels.size() << nl;
label nParcels = 0;
// Output positions
forAllConstIter(Cloud<passiveParticle>, parcels, elmnt)
{
const vector& p = elmnt().position();
ensightFile
<< setw(8) << ++nParcels
<< setw(12) << p.x() << setw(12) << p.y() << setw(12) << p.z()
<< nl;
}
}
else
{
label nParcels = 0;
ensightFile<< setw(8) << nParcels << 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) 2011 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
InApplication
foamToEnsight
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& CloudName,
const bool dataExists
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

10
applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightStream.H
View File

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -57,10 +57,10 @@ class ensightStream
// Private Member Functions
//- Disallow default bitwise copy construct
ensightStream(const ensightStream&);
ensightStream(const ensightStream&) = delete;
//- Disallow default bitwise assignment
void operator=(const ensightStream&);
void operator=(const ensightStream&) = delete;
public:
@ -86,8 +86,6 @@ public:
return name_;
}
virtual bool ascii() const = 0;
virtual void write(const char*) = 0;
virtual void write(const int) = 0;
@ -98,8 +96,6 @@ public:
virtual void writePartHeader(const label) = 0;
};

93
applications/utilities/postProcessing/dataConversion/foamToEnsight/findCloudFields.H Normal file
View File

@ -0,0 +1,93 @@
// check all time directories for the following:
// The fields for each cloud:
HashTable<HashTable<word>> cloudFields;
// Identify if lagrangian data exist at any time step.
if (timeDirs.size() && !noLagrangian)
{
const fileName& baseDir = mesh.time().path();
const fileName& cloudPrefix = regionPrefix/cloud::prefix;
Info<< "Searching for lagrangian ... " << flush;
forAll(timeDirs, timeI)
{
const word& timeName = timeDirs[timeI].name();
// DO NOT USE -->> runTime.setTime(timeDirs[timeI], timeI); <<--
// It incurs a large overhead when done so frequently.
fileNameList cloudDirs = readDir
(
baseDir/timeName/cloudPrefix,
fileName::DIRECTORY
);
forAll(cloudDirs, cloudI)
{
const word& cloudName = cloudDirs[cloudI];
IOobjectList cloudObjs
(
mesh,
timeName,
cloudPrefix/cloudName
);
// clouds always require "positions"
if (cloudObjs.found("positions"))
{
HashTable<HashTable<word>>::iterator cloudIter =
cloudFields.find(cloudName);
if (cloudIter == cloudFields.end())
{
// A newly discovered cloud
cloudFields.insert(cloudName, HashTable<word>());
cloudIter = cloudFields.find(cloudName);
}
forAllConstIter(IOobjectList, cloudObjs, fieldIter)
{
const IOobject obj = *fieldIter();
// Add field and field type
cloudIter().insert
(
obj.name(),
obj.headerClassName()
);
}
}
}
}
// prune out "positions" again since it gets treated specially
forAllIter(HashTable<HashTable<word>>, cloudFields, cloudIter)
{
cloudIter().erase("positions");
}
if (cloudFields.empty())
{
Info<< "none detected." << endl;
}
}
// sorted list of cloud names
const wordList cloudNames(cloudFields.sortedToc());
if (cloudNames.size())
{
// complete the echo information
Info<< "(";
forAll(cloudNames, cloudNo)
{
Info<< ' ' << cloudNames[cloudNo];
}
Info<< " ) " << endl;
}
// ************************************************************************* //

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

@ -3,7 +3,7 @@
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
\\/ M anipulation | Copyright (C) 2016 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -34,27 +34,38 @@ Description
Usage
\b foamToEnsight [OPTION]
Translates OpenFOAM data to EnSight format
Options:
- \par -ascii
Write Ensight data in ASCII format instead of "C Binary"
- \par -patches patchList
Specify particular patches to write.
Specifying an empty list suppresses writing the internalMesh.
- \par -noZero
Exclude the often incomplete initial conditions.
- \par -noLagrangian \n
Suppress writing lagrangian positions and fields.
- \par -noPatches
Suppress writing any patches.
- \par -faceZones zoneList
- \par -patches patchList \n
Specify particular patches to write.
Specifying an empty list suppresses writing the internalMesh.
- \par -faceZones zoneList \n
Specify faceZones to write, with wildcards
- \par -cellZone zoneName
Specify single cellZone to write (not lagrangian)
- \par -width \<n\>\n
Width of EnSight data subdir (default: 8)
Note
Parallel support for cloud data is not supported
- writes to \a EnSight directory to avoid collisions with foamToEnsightParts
- writes to \a EnSight directory to avoid collisions with
foamToEnsightParts
\*---------------------------------------------------------------------------*/
@ -70,14 +81,12 @@ Note
#include "scalarIOField.H"
#include "tensorIOField.H"
#include "ensightFile.H"
#include "ensightMesh.H"
#include "ensightField.H"
#include "ensightParticlePositions.H"
#include "ensightCloudField.H"
#include "ensightCloud.H"
#include "fvc.H"
#include "cellSet.H"
#include "fvMeshSubset.H"
@ -87,11 +96,7 @@ using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
bool inFileNameList
(
const fileNameList& nameList,
const word& name
)
bool inFileNameList(const fileNameList& nameList, const word& name)
{
forAll(nameList, i)
{
@ -105,7 +110,6 @@ bool inFileNameList
}
int main(int argc, char *argv[])
{
timeSelector::addOptions();
@ -122,6 +126,11 @@ int main(int argc, char *argv[])
"write values in nodes"
);
argList::addBoolOption
(
"noLagrangian",
"suppress writing lagrangian positions and fields"
);
argList::addBoolOption
(
"noPatches",
"suppress writing any patches"
@ -151,32 +160,21 @@ int main(int argc, char *argv[])
"word",
"specify cellZone to write"
);
argList::addOption
(
"name",
"subdir",
"define sub-directory name to use for ensight data "
"(default: 'EnSight')"
);
argList::addOption
(
"width",
"n",
"width of ensight data subdir"
);
#include "setRootCase.H"
// Check options
const bool binary = !args.optionFound("ascii");
const bool nodeValues = args.optionFound("nodeValues");
cpuTime timer;
memInfo mem;
Info<< "Initial memory "
<< mem.update().size() << " kB" << endl;
#include "createTime.H"
instantList Times = timeSelector::select0(runTime, args);
#include "createNamedMesh.H"
// Mesh instance (region0 gets filtered out)
fileName regionPrefix = "";
if (regionName != polyMesh::defaultRegion)
{
regionPrefix = regionName;
}
// the volume field types that we handle
const label nVolFieldTypes = 10;
const word volFieldTypes[] =
{
@ -193,38 +191,90 @@ int main(int argc, char *argv[])
volTensorField::Internal::typeName
};
#include "setRootCase.H"
// default to binary output, unless otherwise specified
const IOstream::streamFormat format =
(
args.optionFound("ascii")
? IOstream::ASCII
: IOstream::BINARY
);
const bool nodeValues = args.optionFound("nodeValues");
cpuTime timer;
memInfo mem;
Info<< "Initial memory "
<< mem.update().size() << " kB" << endl;
#include "createTime.H"
instantList timeDirs = timeSelector::select0(runTime, args);
// adjust output width
if (args.optionFound("width"))
{
ensightFile::subDirWidth(args.optionRead<label>("width"));
}
// define sub-directory name to use for EnSight data
fileName ensightDir = "EnSight";
args.optionReadIfPresent("name", ensightDir);
// Path to EnSight directory at case level only
// - For parallel cases, data only written from master
fileName ensightDir = args.rootPath()/args.globalCaseName()/"EnSight";
if (!ensightDir.isAbsolute())
{
ensightDir = args.rootPath()/args.globalCaseName()/ensightDir;
}
const fileName dataDir = ensightDir/"data";
const fileName dataMask = dataDir.name()/ensightFile::mask();
if (Pstream::master())
{
// EnSight and EnSight/data directories must exist
// - remove old data for a clean conversion of everything
if (isDir(ensightDir))
{
rmDir(ensightDir);
}
mkDir(ensightDir);
mkDir(dataDir);
}
#include "createNamedMesh.H"
// Mesh instance (region0 gets filtered out)
fileName regionPrefix;
if (regionName != polyMesh::defaultRegion)
{
regionPrefix = regionName;
}
// Start of case file header output
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
const word prepend = args.globalCaseName() + '.';
OFstream *ensightCaseFilePtr = nullptr;
OFstream *ensightCaseFilePtr(nullptr);
if (Pstream::master())
{
fileName caseFileName = prepend + "case";
Info<< nl << "write case: " << caseFileName.c_str() << endl;
fileName caseFileName = args.globalCaseName() + ".case";
// the case file is always ASCII
Info<< "Converting " << timeDirs.size() << " time steps" << nl
<< "Ensight case: " << caseFileName.c_str() << endl;
// The case file is always ASCII
ensightCaseFilePtr = new OFstream
(
ensightDir/caseFileName,
IOstream::ASCII
);
ensightCaseFilePtr->setf(ios_base::left);
ensightCaseFilePtr->setf(ios_base::scientific, ios_base::floatfield);
ensightCaseFilePtr->precision(5);
*ensightCaseFilePtr
<< "FORMAT" << nl
<< "type: ensight gold" << nl << nl;
@ -253,6 +303,8 @@ int main(int argc, char *argv[])
fieldPatterns = wordReList(args.optionLookup("fields")());
}
const bool noLagrangian = args.optionFound("noLagrangian");
word cellZoneName;
const bool doCellZone = args.optionReadIfPresent("cellZone", cellZoneName);
@ -280,133 +332,84 @@ int main(int argc, char *argv[])
patchPatterns,
selectedZones,
zonePatterns,
binary
format
);
// Set Time to the last time before looking for the lagrangian objects
runTime.setTime(Times.last(), Times.size()-1);
runTime.setTime(timeDirs.last(), timeDirs.size()-1);
IOobjectList objects(mesh, runTime.timeName());
#include "checkMeshMoving.H"
#include "findCloudFields.H"
if (meshMoving)
{
Info<< "Detected a moving mesh (multiple polyMesh/points files)."
<< " Writing meshes for every timestep." << endl;
}
wordHashSet allCloudNames;
if (Pstream::master())
{
word geomFileName = prepend + "0000";
// test the pre-check variable if there is a moving mesh
// time-set for geometries
// TODO: split off into separate time-set,
// but need to verify ensight spec
// test pre check variable if there is a moving mesh
if (meshMoving)
{
geomFileName = prepend + "****";
ensightCaseFile
<< "GEOMETRY" << nl
<< setw(16) << "model: 1"
<< (dataMask/ensightMesh::geometryName).c_str() << nl;
}
ensightCaseFile
<< "GEOMETRY" << nl
<< "model: 1 "
<< (geomFileName + ".mesh").c_str() << nl;
}
// Identify if lagrangian data exists at each time, and add clouds
// to the 'allCloudNames' hash set
forAll(Times, timeI)
{
runTime.setTime(Times[timeI], timeI);
fileNameList cloudDirs = readDir
(
runTime.timePath()/regionPrefix/cloud::prefix,
fileName::DIRECTORY
);
forAll(cloudDirs, cloudI)
{
IOobjectList cloudObjs
(
mesh,
runTime.timeName(),
cloud::prefix/cloudDirs[cloudI]
);
IOobject* positionsPtr = cloudObjs.lookup(word("positions"));
if (positionsPtr)
{
allCloudNames.insert(cloudDirs[cloudI]);
}
}
}
HashTable<HashTable<word>> allCloudFields;
forAllConstIter(wordHashSet, allCloudNames, cloudIter)
{
// Add the name of the cloud(s) to the case file header
if (Pstream::master())
else
{
ensightCaseFile
<< (
"measured: 1 "
+ prepend
+ "****."
+ cloudIter.key()
).c_str()
<< nl;
<< "GEOMETRY" << nl
<< setw(16) << "model:"
<< ensightMesh::geometryName << nl;
}
// Create a new hash table for each cloud
allCloudFields.insert(cloudIter.key(), HashTable<word>());
// Identify the new cloud in the hash table
HashTable<HashTable<word>>::iterator newCloudIter =
allCloudFields.find(cloudIter.key());
// Loop over all times to build list of fields and field types
// for each cloud
forAll(Times, timeI)
// Add the name of the cloud(s) to the case file header
forAll(cloudNames, cloudNo)
{
runTime.setTime(Times[timeI], timeI);
const word& cloudName = cloudNames[cloudNo];
IOobjectList cloudObjs
(
mesh,
runTime.timeName(),
cloud::prefix/cloudIter.key()
);
forAllConstIter(IOobjectList, cloudObjs, fieldIter)
{
const IOobject obj = *fieldIter();
if (obj.name() != "positions")
{
// Add field and field type
newCloudIter().insert
(
obj.name(),
obj.headerClassName()
);
}
}
ensightCaseFile
<< setw(16) << "measured: 1"
<< fileName
(
dataMask/cloud::prefix/cloudName/"positions"
).c_str() << nl;
}
}
Info<< "Startup in "
<< timer.cpuTimeIncrement() << " s, "
<< mem.update().size() << " kB" << nl << endl;
// ignore special fields (_0 fields),
// ignore fields we don't handle,
// ignore fields that are not available for all time-steps
HashTable<bool> fieldsToUse;
label nTimeSteps = 0;
forAll(Times, timeIndex)
forAll(timeDirs, timeIndex)
{
nTimeSteps++;
runTime.setTime(Times[timeIndex], timeIndex);
++nTimeSteps;
runTime.setTime(timeDirs[timeIndex], timeIndex);
word timeName = itoa(timeIndex);
word timeFile = prepend + timeName;
Info<< "Time [" << timeIndex << "] = " << runTime.timeName() << nl;
Info<< "Translating time = " << runTime.timeName() << nl;
if (Pstream::master())
{
// the data/ITER subdirectory must exist
// Note that data/ITER is indeed a valid ensight::FileName
const fileName subDir = ensightFile::subDir(timeIndex);
mkDir(dataDir/subDir);
// place a timestamp in the directory for future reference
OFstream timeStamp(dataDir/subDir/"time");
timeStamp
<< "# timestep time" << nl
<< subDir.c_str() << " " << runTime.timeName() << nl;
}
polyMesh::readUpdateState meshState = mesh.readUpdate();
if (timeIndex != 0 && meshSubsetter.hasSubMesh())
@ -420,7 +423,6 @@ int main(int argc, char *argv[])
meshSubsetter.setLargeCellSubset(c0, 0);
}
if (meshState != polyMesh::UNCHANGED)
{
eMesh.correct();
@ -430,8 +432,7 @@ int main(int argc, char *argv[])
{
eMesh.write
(
ensightDir,
prepend,
dataDir,
timeIndex,
meshMoving,
ensightCaseFile
@ -450,8 +451,9 @@ int main(int argc, char *argv[])
// Cell field data output
// ~~~~~~~~~~~~~~~~~~~~~~
Info<< "Write volume field (";
for (label i=0; i<nVolFieldTypes; i++)
for (label i=0; i<nVolFieldTypes; ++i)
{
wordList fieldNames = objects.names(volFieldTypes[i]);
@ -470,7 +472,7 @@ int main(int argc, char *argv[])
#include "checkData.H"
if (!variableGood)
if (!fieldsToUse[fieldName])
{
continue;
}
@ -491,10 +493,8 @@ int main(int argc, char *argv[])
(
volField(meshSubsetter, vf),
eMesh,
ensightDir,
prepend,
dataDir,
timeIndex,
binary,
nodeValues,
ensightCaseFile
);
@ -506,10 +506,8 @@ int main(int argc, char *argv[])
(
volField(meshSubsetter, vf),
eMesh,
ensightDir,
prepend,
dataDir,
timeIndex,
binary,
nodeValues,
ensightCaseFile
);
@ -521,10 +519,8 @@ int main(int argc, char *argv[])
(
volField(meshSubsetter, vf),
eMesh,
ensightDir,
prepend,
dataDir,
timeIndex,
binary,
nodeValues,
ensightCaseFile
);
@ -536,10 +532,8 @@ int main(int argc, char *argv[])
(
volField(meshSubsetter, vf),
eMesh,
ensightDir,
prepend,
dataDir,
timeIndex,
binary,
nodeValues,
ensightCaseFile
);
@ -551,10 +545,8 @@ int main(int argc, char *argv[])
(
volField(meshSubsetter, vf),
eMesh,
ensightDir,
prepend,
dataDir,
timeIndex,
binary,
nodeValues,
ensightCaseFile
);
@ -570,10 +562,8 @@ int main(int argc, char *argv[])
(
volField<scalar>(meshSubsetter, df),
eMesh,
ensightDir,
prepend,
dataDir,
timeIndex,
binary,
nodeValues,
ensightCaseFile
);
@ -588,10 +578,8 @@ int main(int argc, char *argv[])
(
volField<vector>(meshSubsetter, df),
eMesh,
ensightDir,
prepend,
dataDir,
timeIndex,
binary,
nodeValues,
ensightCaseFile
);
@ -607,10 +595,8 @@ int main(int argc, char *argv[])
(
volField<sphericalTensor>(meshSubsetter, df),
eMesh,
ensightDir,
prepend,
dataDir,
timeIndex,
binary,
nodeValues,
ensightCaseFile
);
@ -625,10 +611,8 @@ int main(int argc, char *argv[])
(
volField<symmTensor>(meshSubsetter, df),
eMesh,
ensightDir,
prepend,
dataDir,
timeIndex,
binary,
nodeValues,
ensightCaseFile
);
@ -643,24 +627,29 @@ int main(int argc, char *argv[])
(
volField<tensor>(meshSubsetter, df),
eMesh,
ensightDir,
prepend,
dataDir,
timeIndex,
binary,
nodeValues,
ensightCaseFile
);
}
else
{
// Do not currently handle this type - blacklist for the future.
fieldsToUse.set(fieldName, false);
}
}
}
Info<< " )" << nl;
// Cloud field data output
// ~~~~~~~~~~~~~~~~~~~~~~~
forAllConstIter(HashTable<HashTable<word>>, allCloudFields, cloudIter)
forAll(cloudNames, cloudNo)
{
const word& cloudName = cloudIter.key();
const word& cloudName = cloudNames[cloudNo];
const HashTable<word>& theseCloudFields = cloudFields[cloudName];
fileNameList currentCloudDirs = readDir
(
@ -668,17 +657,22 @@ int main(int argc, char *argv[])
fileName::DIRECTORY
);
Info<< "Write " << cloudName << " (";
bool cloudExists = inFileNameList(currentCloudDirs, cloudName);
reduce(cloudExists, orOp<bool>());
ensightParticlePositions
(
mesh,
ensightDir,
timeFile,
dataDir,
timeIndex,
cloudName,
cloudExists
cloudExists,
format
);
forAllConstIter(HashTable<word>, cloudIter(), fieldIter)
forAllConstIter(HashTable<word>, theseCloudFields, fieldIter)
{
const word& fieldName = fieldIter.key();
const word& fieldType = fieldIter();
@ -696,17 +690,20 @@ int main(int argc, char *argv[])
(
false
);
reduce(fieldExists, orOp<bool>());
if (fieldType == scalarIOField::typeName)
{
ensightCloudField<scalar>
(
fieldObject,
ensightDir,
prepend,
dataDir,
timeIndex,
cloudName,
cloudNo,
ensightCaseFile,
fieldExists
fieldExists,
format
);
}
else if (fieldType == vectorIOField::typeName)
@ -714,37 +711,34 @@ int main(int argc, char *argv[])
ensightCloudField<vector>
(
fieldObject,
ensightDir,
prepend,
dataDir,
timeIndex,
cloudName,
cloudNo,
ensightCaseFile,
fieldExists
fieldExists,
format
);
}
else
{
Info<< "Unable to convert field type " << fieldType
<< " for field " << fieldName << endl;
}
}
Info<< " )" << nl;
}
Info<< "Wrote in "
<< timer.cpuTimeIncrement() << " s, "
<< mem.update().size() << " kB" << endl;
<< mem.update().size() << " kB" << nl << nl;
}
#include "ensightCaseTail.H"
if (Pstream::master())
if (ensightCaseFilePtr) // on master only
{
delete ensightCaseFilePtr;
}
Info<< "\nEnd: "
Info<< "End: "
<< timer.elapsedCpuTime() << " s, "
<< mem.update().peak() << " kB (peak)\n" << endl;
<< mem.update().peak() << " kB (peak)" << nl << endl;
return 0;
}

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

@ -1,61 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "itoa.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
word itoa(const label n)
{
const label offset = '0';
const label length = 4;
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
// ************************************************************************* //

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

@ -1,47 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
InApplication
foamToEnsight
Description
\*---------------------------------------------------------------------------*/
#include "word.H"
#include "label.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
word itoa(const label n);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

49
applications/utilities/postProcessing/dataConversion/foamToEnsightParts/checkHasMovingMesh.H
View File

@ -2,18 +2,47 @@
// - could restrict to the selected times
bool hasMovingMesh = false;
if (timeDirs.size() > 1)
if (timeDirs.size() > 1 && Pstream::master())
{
hasMovingMesh = true;
for (label i=0; i < timeDirs.size() && hasMovingMesh; ++i)
// We already loaded a mesh (usually from constant).
// See if any other "polyMesh/points" files exist too.
const fileName& baseDir = mesh.time().path();
Info<< "Search for moving mesh ... " << flush;
forAll(timeDirs, timeI)
{
hasMovingMesh = IOobject
hasMovingMesh =
(
"points",
timeDirs[i].name(),
polyMesh::meshSubDir,
mesh,
IOobject::NO_READ
).typeHeaderOk<pointIOField>(true);
isDir(baseDir/timeDirs[timeI].name()/polyMesh::meshSubDir)
&& IOobject
(
"points",
timeDirs[timeI].name(),
polyMesh::meshSubDir,
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE,
false // no register
).typeHeaderOk<pointIOField>(true)
);
if (hasMovingMesh)
{
break;
}
}
if (hasMovingMesh)
{
Info<< "found." << nl
<< " Writing meshes for every timestep." << endl;
}
else
{
Info<< "none detected." << endl;
}
}
reduce(hasMovingMesh, orOp<bool>());

70
applications/utilities/postProcessing/dataConversion/foamToEnsightParts/ensightOutputCase.H
View File

@ -58,35 +58,36 @@ forAllConstIter(HashTable<word>, volumeFields, fieldIter)
if (fieldType == volScalarField::typeName)
{
ensightType = "scalar";
ensightType = ensightPTraits<scalar>::typeName;
}
else if (fieldType == volVectorField::typeName)
{
ensightType = "vector";
ensightType = ensightPTraits<vector>::typeName;
}
else if (fieldType == volSphericalTensorField::typeName)
{
ensightType = "tensor symm";
ensightType = ensightPTraits<sphericalTensor>::typeName;
}
else if (fieldType == volSymmTensorField::typeName)
{
ensightType = "tensor symm";
ensightType = ensightPTraits<symmTensor>::typeName;
}
else if (fieldType == volTensorField::typeName)
{
ensightType = "tensor asym";
ensightType = ensightPTraits<tensor>::typeName;
}
else
{
continue;
}
if (ensightType.size())
{
ensightCaseEntry
(
caseFile,
ensightType,
fieldName,
dataMask
);
}
ensightCaseEntry
(
caseFile,
ensightType,
fieldName,
dataMask
);
}
@ -104,30 +105,31 @@ forAllConstIter(HashTable<HashTable<word>>, cloudFields, cloudIter)
if (fieldType == scalarIOField::typeName)
{
ensightType = "scalar";
ensightType = ensightPTraits<scalar>::typeName;
}
else if (fieldType == vectorIOField::typeName)
{
ensightType = "vector";
ensightType = ensightPTraits<vector>::typeName;
}
else if (fieldType == tensorIOField::typeName)
{
ensightType = "tensor";
ensightType = ensightPTraits<tensor>::typeName;
}
else
{
continue;
}
if (ensightType.size())
{
ensightCaseEntry
(
caseFile,
ensightType,
fieldName,
dataMask,
cloud::prefix/cloudName,
cloudNo,
2
);
}
ensightCaseEntry
(
caseFile,
ensightType,
fieldName,
dataMask,
cloud::prefix/cloudName,
cloudNo,
2
);
}
cloudNo++;
}
@ -162,7 +164,7 @@ if (fieldTimesUsed.size())
count = 0;
forAll(fieldTimesUsed, i)
{
const label& index = fieldTimesUsed[i];
const label index = fieldTimesUsed[i];
caseFile
<< " " << setw(12) << timeIndices[index] + timeCorrection;
@ -203,7 +205,7 @@ if (geometryTimesUsed.size())
count = 0;
forAll(geometryTimesUsed, i)
{
const label& index = geometryTimesUsed[i];
const label index = geometryTimesUsed[i];
caseFile
<< " " << setw(12) << timeIndices[index] + timeCorrection;
@ -249,7 +251,7 @@ forAllConstIter(HashTable<DynamicList<label>>, cloudTimesUsed, cloudIter)
count = 0;
forAll(timesUsed, i)
{
const label& index = timesUsed[i];
const label index = timesUsed[i];
caseFile
<< " " << setw(12) << timeIndices[index] + timeCorrection;

25
applications/utilities/postProcessing/dataConversion/foamToEnsightParts/ensightOutputFunctions.C
View File

@ -24,6 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "ensightOutputFunctions.H"
#include "ensightPTraits.H"
#include "passiveParticle.H"
#include "IOField.H"
@ -171,11 +172,8 @@ void Foam::ensightLagrangianField
// when writing positions
ensightFile os(dataDir, postFileName, format);
os.write
(
// description
string(postFileName + " with " + pTraits<Type>::typeName + " values")
);
// description
os.write(string(postFileName + " <" + pTraits<Type>::typeName + ">"));
os.newline();
IOField<Type> field(fieldObject);
@ -187,21 +185,20 @@ void Foam::ensightLagrangianField
{
Type val = field[i];
if (mag(val) < 1.0e-90)
if (mag(val) < 1e-90)
{
val = Zero;
}
for (direction cmpt=0; cmpt < pTraits<Type>::nComponents; cmpt++)
for (direction d=0; d < pTraits<Type>::nComponents; ++d)
{
os.write( component(val, cmpt) );
}
label cmpt = ensightPTraits<Type>::componentOrder[d];
os.write(component(val, cmpt));
count += pTraits<Type>::nComponents;
if (count % 6 == 0)
{
os.newline();
if (++count % 6 == 0)
{
os.newline();
}
}
}

54
applications/utilities/postProcessing/dataConversion/foamToEnsightParts/findFields.H
View File

@ -8,7 +8,10 @@ HashTable<HashTable<word>> cloudFields;
if (timeDirs.size())
{
IOobjectList objs(mesh, timeDirs.last().name());
const fileName& cloudPrefix = regionPrefix/cloud::prefix;
const word& lastTimeName = timeDirs.last().name();
IOobjectList objs(mesh, lastTimeName);
forAllConstIter(IOobjectList, objs, fieldIter)
{
@ -31,14 +34,17 @@ if (timeDirs.size())
//
// now check for lagrangian/<cloudName>
//
fileNameList cloudDirs = readDir
(
runTime.path()
/ timeDirs.last().name()
/ regionPrefix
/ cloud::prefix,
fileName::DIRECTORY
);
fileNameList cloudDirs;
if (!noLagrangian)
{
cloudDirs = readDir
(
runTime.path()
/ lastTimeName
/ cloudPrefix,
fileName::DIRECTORY
);
}
forAll(cloudDirs, cloudI)
{
@ -54,8 +60,8 @@ if (timeDirs.size())
IOobjectList objs
(
mesh,
timeDirs.last().name(),
cloud::prefix/cloudName
lastTimeName,
cloudPrefix/cloudName
);
bool hasPositions = false;
@ -89,17 +95,27 @@ if (timeDirs.size())
//
for (label i=0; volumeFields.size() && i < timeDirs.size(); ++i)
{
IOobjectList objs(mesh, timeDirs[i].name());
const word& timeName = timeDirs[i].name();
forAllIter(HashTable<word>, volumeFields, fieldIter)
// Everything is potentially missing, unless we discover otherwise
wordHashSet missing(volumeFields);
// Avoid -->> IOobjectList objs(mesh, timeName); <<--
// Too much overhead when done so frequently.
fileNameList contents = readDir
(
runTime.path()
/ timeName,
fileName::FILE
);
forAll(contents, fileI)
{
const word& fieldName = fieldIter.key();
if (!objs.found(fieldName))
{
volumeFields.erase(fieldIter);
}
missing.erase(contents[fileI].name());
}
volumeFields.erase(missing);
}
}

115
applications/utilities/postProcessing/dataConversion/foamToEnsightParts/foamToEnsightParts.C
View File

@ -48,6 +48,13 @@ Usage
Ignore the time index contained in the time file and use a
simple indexing when creating the \c Ensight/data/######## files.
- \par -noLagrangian \n
Suppress writing lagrangian positions and fields.
- \par -index \<start\>\n
Ignore the time index contained in the time file and use a
simple indexing when creating the \c Ensight/data/######## files.
- \par -noMesh
Suppress writing the geometry. Can be useful for converting partial
results for a static geometry.
@ -83,8 +90,8 @@ using namespace Foam;
int main(int argc, char *argv[])
{
// enable -constant
// probably don't need -withZero though, since the fields are vetted
// Enable -constant
// Probably don't need -withZero though, since the fields are vetted
// afterwards anyhow
timeSelector::addOptions(true, false);
argList::noParallel();
@ -101,6 +108,11 @@ int main(int argc, char *argv[])
"and use simple indexing when creating the files"
);
argList::addBoolOption
(
"noLagrangian",
"suppress writing lagrangian positions and fields"
);
argList::addBoolOption
(
"noMesh",
"suppress writing the geometry. "
@ -120,7 +132,7 @@ int main(int argc, char *argv[])
"width of Ensight data subdir"
);
// the volume field types that we handle
// The volume field types that we handle
wordHashSet volFieldTypes;
volFieldTypes.insert(volScalarField::typeName);
volFieldTypes.insert(volVectorField::typeName);
@ -128,7 +140,7 @@ int main(int argc, char *argv[])
volFieldTypes.insert(volSymmTensorField::typeName);
volFieldTypes.insert(volTensorField::typeName);
// the lagrangian field types that we handle
// The lagrangian field types that we handle
wordHashSet cloudFieldTypes;
cloudFieldTypes.insert(scalarIOField::typeName);
cloudFieldTypes.insert(vectorIOField::typeName);
@ -145,30 +157,32 @@ int main(int argc, char *argv[])
#include "createTime.H"
// get times list
// Get times list
instantList timeDirs = timeSelector::select0(runTime, args);
// default to binary output, unless otherwise specified
IOstream::streamFormat format = IOstream::BINARY;
if (args.optionFound("ascii"))
{
format = IOstream::ASCII;
}
// Default to binary output, unless otherwise specified
const IOstream::streamFormat format =
(
args.optionFound("ascii")
? IOstream::ASCII
: IOstream::BINARY
);
// control for renumbering iterations
// Control for renumbering iterations
label indexingNumber = 0;
bool optIndex = args.optionReadIfPresent("index", indexingNumber);
const bool optIndex = args.optionReadIfPresent("index", indexingNumber);
const bool noLagrangian = args.optionFound("noLagrangian");
// always write the geometry, unless the -noMesh option is specified
// Always write the geometry, unless the -noMesh option is specified
bool optNoMesh = args.optionFound("noMesh");
// adjust output width
// Adjust output width
if (args.optionFound("width"))
{
ensightFile::subDirWidth(args.optionRead<label>("width"));
}
// define sub-directory name to use for Ensight data
// Define sub-directory name to use for Ensight data
fileName ensightDir = "Ensight";
args.optionReadIfPresent("name", ensightDir);
@ -190,7 +204,7 @@ int main(int argc, char *argv[])
<< " " << ensightDir << endl;
}
// as per mkdir -p "Ensight/data"
// As per mkdir -p "Ensight/data"
mkDir(ensightDir);
mkDir(dataDir);
@ -204,10 +218,15 @@ int main(int argc, char *argv[])
regionPrefix = regionName;
}
if (Pstream::master())
{
Info<< "Converting " << timeDirs.size() << " time steps" << endl;
}
// Construct the list of ensight parts for the entire mesh
ensightParts partsList(mesh);
// write summary information
// Write summary information
{
OFstream partsInfoFile(ensightDir/"partsInfo");
@ -226,7 +245,7 @@ int main(int argc, char *argv[])
}
// map times used
// Map times used
Map<scalar> timeIndices;
// TODO: Track the time indices used by the geometry
@ -244,6 +263,9 @@ int main(int argc, char *argv[])
cloudTimesUsed.insert(cloudIter.key(), DynamicList<label>());
}
Info<< "Startup in "
<< timer.cpuTimeIncrement() << " s, "
<< mem.update().size() << " kB" << nl << endl;
forAll(timeDirs, timeI)
{
@ -251,15 +273,15 @@ int main(int argc, char *argv[])
#include "getTimeIndex.H"
// remember the time index for the volume fields
// Remember the time index for the volume fields
fieldTimesUsed.append(timeIndex);
// the data/ITER subdirectory must exist
// The data/ITER subdirectory must exist
// Note that data/ITER is indeed a valid ensight::FileName
const fileName subDir = ensightFile::subDir(timeIndex);
mkDir(dataDir/subDir);
// place a timestamp in the directory for future reference
// Place a timestamp in the directory for future reference
{
OFstream timeStamp(dataDir/subDir/"time");
timeStamp
@ -280,7 +302,7 @@ int main(int argc, char *argv[])
{
if (hasMovingMesh)
{
// remember the time index for the geometry
// Remember the time index for the geometry
geometryTimesUsed.append(timeIndex);
}
@ -294,7 +316,7 @@ int main(int argc, char *argv[])
}
}
Info<< "write volume field (" << flush;
Info<< "Write volume field (" << flush;
forAllConstIter(HashTable<word>, volumeFields, fieldIter)
{
@ -376,19 +398,13 @@ int main(int argc, char *argv[])
}
Info<< " )" << endl;
// check for clouds
// Check for clouds
forAllConstIter(HashTable<HashTable<word>>, cloudFields, cloudIter)
{
const word& cloudName = cloudIter.key();
const fileName& cloudPrefix = regionPrefix/cloud::prefix;
if
(
!isDir
(
runTime.timePath()/regionPrefix/
cloud::prefix/cloudName
)
)
if (!isDir(runTime.timePath()/cloudPrefix/cloudName))
{
continue;
}
@ -397,28 +413,25 @@ int main(int argc, char *argv[])
(
mesh,
runTime.timeName(),
cloud::prefix/cloudName
cloudPrefix/cloudName
);
// check that the positions field is present for this time
IOobject* positionPtr = cloudObjs.lookup(word("positions"));
if (positionPtr != nullptr)
{
ensightParticlePositions
(
mesh,
dataDir,
subDir,
cloudName,
format
);
}
else
// Check that the positions field is present for this time
if (!cloudObjs.found("positions"))
{
continue;
}
Info<< "write " << cloudName << " (" << flush;
Info<< "Write " << cloudName << " ( positions" << flush;
ensightParticlePositions
(
mesh,
dataDir,
subDir,
cloudName,
format
);
forAllConstIter(HashTable<word>, cloudIter(), fieldIter)
{
@ -430,7 +443,7 @@ int main(int argc, char *argv[])
if (!fieldObject)
{
Info<< "missing "
<< runTime.timeName()/cloud::prefix/cloudName
<< runTime.timeName()/cloudPrefix/cloudName
/ fieldName
<< endl;
continue;
@ -476,7 +489,7 @@ int main(int argc, char *argv[])
Info<< " )" << endl;
// remember the time index
// Remember the time index
cloudTimesUsed[cloudName].append(timeIndex);
}

2
applications/utilities/postProcessing/dataConversion/foamToEnsightParts/getTimeIndex.H
View File

@ -39,5 +39,5 @@
}
timeIndices.insert(timeIndex, timeDirs[timeI].value());
Info<< "\nTime [" << timeIndex << "] = " << runTime.timeName() << nl;
Info<< nl << "Time [" << timeIndex << "] = " << runTime.timeName() << nl;

71
applications/utilities/postProcessing/dataConversion/foamToVTK/findClouds.H Normal file
View File

@ -0,0 +1,71 @@
// check all time directories for the following:
// Any cloud names:
HashSet<fileName> allCloudDirs;
if (timeDirs.size() && !noLagrangian)
{
const fileName& baseDir = mesh.time().path();
const fileName& cloudPrefix = regionPrefix/cloud::prefix;
Info<< "Searching for lagrangian ... " << flush;
forAll(timeDirs, timeI)
{
const word& timeName = timeDirs[timeI].name();
// DO NOT USE -->> runTime.setTime(timeDirs[timeI], timeI); <<--
// It incurs a large overhead when done so frequently.
fileNameList cloudDirs = readDir
(
baseDir/timeName/cloudPrefix,
fileName::DIRECTORY
);
forAll(cloudDirs, cloudI)
{
const word& cloudName = cloudDirs[cloudI];
IOobjectList cloudObjs
(
mesh,
timeName,
cloudPrefix/cloudName
);
// clouds always require "positions"
if (cloudObjs.found("positions"))
{
if (allCloudDirs.insert(cloudName))
{
Info<< "At time: " << timeName
<< " detected cloud directory : " << cloudName
<< endl;
}
}
}
}
if (allCloudDirs.empty())
{
Info<< "none detected." << endl;
}
}
// sorted list of cloud names
const fileNameList cloudNames(allCloudDirs.sortedToc());
if (cloudNames.size())
{
// complete the echo information
Info<< "(";
forAll(cloudNames, cloudNo)
{
Info<< ' ' << cloudNames[cloudNo];
}
Info<< " ) " << endl;
}
// ************************************************************************* //

65
applications/utilities/postProcessing/dataConversion/foamToVTK/foamToVTK.C
View File

@ -72,7 +72,10 @@ Usage
- \par -noInternal
Do not generate file for mesh, only for patches
- \par -noPointValues
- \par -noLagrangian \n
Suppress writing lagrangian positions and fields.
- \par -noPointValues \n
No pointFields
- \par -noFaceZones
@ -291,6 +294,12 @@ int main(int argc, char *argv[])
"noInternal",
"do not generate file for mesh, only for patches"
);
argList::addBoolOption
(
"noLagrangian",
"suppress writing lagrangian positions and fields"
);
argList::addBoolOption
(
"noPointValues",
@ -337,6 +346,7 @@ int main(int argc, char *argv[])
const bool doLinks = !args.optionFound("noLinks");
bool binary = !args.optionFound("ascii");
const bool useTimeName = args.optionFound("useTimeName");
const bool noLagrangian = args.optionFound("noLagrangian");
// Decomposition of polyhedral cells into tets/pyramids cells
vtkTopo::decomposePoly = !args.optionFound("poly");
@ -409,8 +419,7 @@ int main(int argc, char *argv[])
fileName fvPath(runTime.path()/"VTK");
// Directory of mesh (region0 gets filtered out)
fileName regionPrefix = "";
fileName regionPrefix;
if (regionName != polyMesh::defaultRegion)
{
fvPath = fvPath/regionName;
@ -448,43 +457,7 @@ int main(int argc, char *argv[])
<< timer.cpuTimeIncrement() << " s, "
<< mem.update().size() << " kB" << endl;
// Scan for all possible lagrangian clouds
HashSet<fileName> allCloudDirs;
forAll(timeDirs, timeI)
{
runTime.setTime(timeDirs[timeI], timeI);
fileNameList cloudDirs
(
readDir
(
runTime.timePath()/regionPrefix/cloud::prefix,
fileName::DIRECTORY
)
);
forAll(cloudDirs, i)
{
IOobjectList sprayObjs
(
mesh,
runTime.timeName(),
cloud::prefix/cloudDirs[i]
);
IOobject* positionsPtr = sprayObjs.lookup(word("positions"));
if (positionsPtr)
{
if (allCloudDirs.insert(cloudDirs[i]))
{
Info<< "At time: " << runTime.timeName()
<< " detected cloud directory : " << cloudDirs[i]
<< endl;
}
}
}
}
#include "findClouds.H"
forAll(timeDirs, timeI)
{
@ -492,7 +465,7 @@ int main(int argc, char *argv[])
Info<< "Time: " << runTime.timeName() << endl;
word timeDesc =
const word timeDesc =
useTimeName ? runTime.timeName() : Foam::name(runTime.timeIndex());
// Check for new polyMesh/ and update mesh, fvMeshSubset and cell
@ -664,7 +637,7 @@ int main(int argc, char *argv[])
+ dtf.size();
// Construct pointMesh only if nessecary since constructs edge
// Construct pointMesh only if necessary since constructs edge
// addressing (expensive on polyhedral meshes)
if (noPointValues)
{
@ -1152,9 +1125,9 @@ int main(int argc, char *argv[])
//
//---------------------------------------------------------------------
forAllConstIter(HashSet<fileName>, allCloudDirs, iter)
forAll(cloudNames, cloudNo)
{
const fileName& cloudName = iter.key();
const fileName& cloudName = cloudNames[cloudNo];
// Always create the cloud directory.
mkDir(fvPath/cloud::prefix/cloudName);
@ -1175,9 +1148,7 @@ int main(int argc, char *argv[])
cloud::prefix/cloudName
);
IOobject* positionsPtr = sprayObjs.lookup(word("positions"));
if (positionsPtr)
if (sprayObjs.found("positions"))
{
wordList labelNames(sprayObjs.names(labelIOField::typeName));
Info<< " labels :";