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/test/fvc2D/Make/files Normal file
View File

@ -0,0 +1,3 @@
Test-fvc2D.C
EXE = $(FOAM_USER_APPBIN)/Test-fvc2D

7
applications/test/fvc2D/Make/options Normal file
View File

@ -0,0 +1,7 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude
EXE_LIBS = \
-lfiniteVolume \
-lmeshTools

45
applications/utilities/postProcessing/dataConversion/foamToEnsight/itoa.H → applications/test/fvc2D/Test-fvc2D.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2016 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -21,27 +21,52 @@ License
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
Application
test
Description
Finite volume method test code for 2-D space.
\*---------------------------------------------------------------------------*/
#include "word.H"
#include "label.H"
#include "fvCFD.H"
#include "vector2D.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef GeometricField<vector2D, fvPatchField, volMesh> volVector2DField;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
defineTemplate2TypeNameAndDebug(volVector2DField::Internal, 0);
defineTemplateTypeNameAndDebug(volVector2DField, 0);
word itoa(const label n);
typedef fvPatchField<vector2D> fvPatchVector2DField;
makeFvPatchField(fvPatchVector2DField)
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
GeometricField<vector2D, fvPatchField, volMesh> fld
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
Info<< "end" << endl;
}
// ************************************************************************* //

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

38
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.size() > 2 && fieldName(fieldName.size()-2, 2) == "_0"
? false
: IOobject
(
fieldName,
Times[n1].name(),
timeDirs[n1].name(),
mesh,
IOobject::NO_READ
).typeHeaderOk<volScalarField>(false);
).typeHeaderOk<volScalarField>(false)
);
if (variableGood)
{
break;
}
}
reduce(variableGood, andOp<bool>());
fieldsToUse.set(fieldName, variableGood);
}

45
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
IOobject::NO_READ,
IOobject::NO_WRITE,
false // no register
).typeHeaderOk<pointIOField>(true)
);
if (io.typeHeaderOk<pointIOField>(true))
if (meshMoving)
{
meshMoving = true;
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;
}
}
// ************************************************************************* //

298
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"
@ -77,6 +77,8 @@ volField
IOobject io(df);
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)
@ -763,7 +745,7 @@ void ensightPointField
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;
}
}

28
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.
@ -63,6 +63,11 @@ class ensightStream;
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;
}
// ************************************************************************* //

396
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
<< "model: 1 "
<< (geomFileName + ".mesh").c_str() << nl;
<< setw(16) << "model: 1"
<< (dataMask/ensightMesh::geometryName).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
ensightCaseFile
<< setw(16) << "measured: 1"
<< fileName
(
mesh,
runTime.timeName(),
cloud::prefix/cloudIter.key()
);
dataMask/cloud::prefix/cloudName/"positions"
).c_str() << nl;
}
}
forAllConstIter(IOobjectList, cloudObjs, fieldIter)
{
const IOobject obj = *fieldIter();
Info<< "Startup in "
<< timer.cpuTimeIncrement() << " s, "
<< mem.update().size() << " kB" << nl << endl;
if (obj.name() != "positions")
{
// Add field and field type
newCloudIter().insert
(
obj.name(),
obj.headerClassName()
);
}
}
}
}
// 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
// ************************************************************************* //

43
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 =
(
isDir(baseDir/timeDirs[timeI].name()/polyMesh::meshSubDir)
&& IOobject
(
"points",
timeDirs[i].name(),
timeDirs[timeI].name(),
polyMesh::meshSubDir,
mesh,
IOobject::NO_READ
).typeHeaderOk<pointIOField>(true);
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>());

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

@ -58,27 +58,29 @@ 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,
@ -86,7 +88,6 @@ forAllConstIter(HashTable<word>, volumeFields, fieldIter)
fieldName,
dataMask
);
}
}
@ -104,19 +105,21 @@ 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,
@ -128,7 +131,6 @@ forAllConstIter(HashTable<HashTable<word>>, cloudFields, cloudIter)
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;

19
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")
);
os.write(string(postFileName + " <" + pTraits<Type>::typeName + ">"));
os.newline();
IOField<Type> field(fieldObject);
@ -187,23 +185,22 @@ 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)
if (++count % 6 == 0)
{
os.newline();
}
}
}
// add final newline if required
if (count % 6)

44
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
fileNameList cloudDirs;
if (!noLagrangian)
{
cloudDirs = readDir
(
runTime.path()
/ timeDirs.last().name()
/ regionPrefix
/ cloud::prefix,
/ 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)
{
const word& fieldName = fieldIter.key();
// Everything is potentially missing, unless we discover otherwise
wordHashSet missing(volumeFields);
if (!objs.found(fieldName))
// Avoid -->> IOobjectList objs(mesh, timeName); <<--
// Too much overhead when done so frequently.
fileNameList contents = readDir
(
runTime.path()
/ timeName,
fileName::FILE
);
forAll(contents, fileI)
{
volumeFields.erase(fieldIter);
}
missing.erase(contents[fileI].name());
}
volumeFields.erase(missing);
}
}

105
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,13 +413,17 @@ 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)
// Check that the positions field is present for this time
if (!cloudObjs.found("positions"))
{
continue;
}
Info<< "Write " << cloudName << " ( positions" << flush;
ensightParticlePositions
(
mesh,
@ -412,13 +432,6 @@ int main(int argc, char *argv[])
cloudName,
format
);
}
else
{
continue;
}
Info<< "write " << cloudName << " (" << flush;
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 :";

14
src/conversion/ensight/file/ensightGeoFile.C
View File

@ -24,14 +24,26 @@ License
\*---------------------------------------------------------------------------*/
#include "ensightGeoFile.H"
#include "foamVersion.H"
// Macros to stringify macro contents.
#define STRINGIFY(content) #content
#define STRING_QUOTE(input) STRINGIFY(input)
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void Foam::ensightGeoFile::initialize()
{
#ifdef OPENFOAM_PLUS
string desc2("Written by OpenFOAM+ " STRING_QUOTE(OPENFOAM_PLUS));
#else
string desc2("Written by OpenFOAM-" + string(Foam::FOAMversion));
#endif
writeBinaryHeader();
write("Ensight Geometry File"); newline(); // description line 1
write("====================="); newline(); // description line 2
write(desc2); newline(); // description line 2
write("node id assign"); newline();
write("element id assign"); newline();
}

21
src/conversion/ensight/part/ensightPart.H
View File

@ -311,27 +311,6 @@ public:
//- Helper: write geometry given the pointField
void writeGeometry(ensightGeoFile&, const pointField&) const;
//- Write scalar field
// optionally write data per node
void writeScalarField
(
ensightFile&,
const List<scalar>& field,
const bool perNode = false
) const;
//- Write vector field components
// optionally write data per node
void writeVectorField
(
ensightFile&,
const List<scalar>& field0,
const List<scalar>& field1,
const List<scalar>& field2,
const bool perNode = false
) const;
//- Write generalized field components
// optionally write data per node
template<class Type>

72
src/conversion/ensight/part/ensightPartIO.C
View File

@ -213,78 +213,6 @@ void Foam::ensightPart::writeGeometry
}
void Foam::ensightPart::writeScalarField
(
ensightFile& os,
const List<scalar>& field,
const bool perNode
) const
{
if (size() && field.size() && (os.allowUndef() || isFieldDefined(field)))
{
writeHeader(os);
if (perNode)
{
os.writeKeyword("coordinates");
writeFieldList(os, field, labelUList::null());
}
else
{
forAll(elementTypes(), elemI)
{
const labelUList& idList = elemLists_[elemI];
if (idList.size())
{
os.writeKeyword(elementTypes()[elemI]);
writeFieldList(os, field, idList);
}
}
}
}
}
void Foam::ensightPart::writeVectorField
(
ensightFile& os,
const List<scalar>& field0,
const List<scalar>& field1,
const List<scalar>& field2,
const bool perNode
) const
{
if (size() && field0.size() && (os.allowUndef() || isFieldDefined(field0)))
{
writeHeader(os);
if (perNode)
{
os.writeKeyword("coordinates");
writeFieldList(os, field0, labelUList::null());
writeFieldList(os, field1, labelUList::null());
writeFieldList(os, field2, labelUList::null());
}
else
{
forAll(elementTypes(), elemI)
{
const labelUList& idList = elemLists_[elemI];
if (idList.size())
{
os.writeKeyword(elementTypes()[elemI]);
writeFieldList(os, field0, idList);
writeFieldList(os, field1, idList);
writeFieldList(os, field2, idList);
}
}
}
}
}
// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
Foam::Ostream& Foam::operator<<

19
src/conversion/ensight/part/ensightPartTemplates.C
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.
@ -27,6 +27,7 @@ Description
\*---------------------------------------------------------------------------*/
#include "ensightPart.H"
#include "ensightPTraits.H"
// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
@ -45,13 +46,9 @@ void Foam::ensightPart::writeField
if (perNode)
{
os.writeKeyword("coordinates");
for
(
direction cmpt=0;
cmpt < pTraits<Type>::nComponents;
++cmpt
)
for (direction d=0; d < pTraits<Type>::nComponents; ++d)
{
label cmpt = ensightPTraits<Type>::componentOrder[d];
writeFieldList(os, field.component(cmpt), labelUList::null());
}
}
@ -65,13 +62,9 @@ void Foam::ensightPart::writeField
{
os.writeKeyword(elementTypes()[elemI]);
for
(
direction cmpt=0;
cmpt < pTraits<Type>::nComponents;
++cmpt
)
for (direction d=0; d < pTraits<Type>::nComponents; ++d)
{
label cmpt = ensightPTraits<Type>::componentOrder[d];
writeFieldList(os, field.component(cmpt), idList);
}
}

53
src/conversion/ensight/part/ensightParts.C
View File

@ -225,59 +225,6 @@ void Foam::ensightParts::writeData(Ostream& os) const
}
void Foam::ensightParts::writeScalarField
(
ensightFile& os,
const List<scalar>& field,
const bool useFaceData,
const bool perNode
) const
{
forAll(partsList_, partI)
{
if
(
useFaceData
? partsList_[partI].isFaceData()
: partsList_[partI].isCellData()
)
{
partsList_[partI].writeScalarField(os, field, perNode);
}
}
}
void Foam::ensightParts::writeVectorField
(
ensightFile& os,
const List<scalar>& field0,
const List<scalar>& field1,
const List<scalar>& field2,
const bool useFaceData,
const bool perNode
) const
{
forAll(partsList_, partI)
{
if
(
useFaceData
? partsList_[partI].isFaceData()
: partsList_[partI].isCellData()
)
{
partsList_[partI].writeVectorField
(
os,
field0, field1, field2,
perNode
);
}
}
}
// * * * * * * * * * * * * * * * * IOStream operators * * * * * * * * * * * //
Foam::ensightGeoFile& Foam::operator<<

25
src/conversion/ensight/part/ensightParts.H
View File

@ -115,31 +115,6 @@ public:
//- Write the lists
void writeData(Ostream&) const;
//- Write (volume) scalar field
// optionally write data for face parts
// optionally write data per node
void writeScalarField
(
ensightFile&,
const List<scalar>& field,
const bool useFaceData = false,
const bool perNode = false
) const;
//- Write (volume) vector field components
// optionally write data for face parts
// optionally write data per node
void writeVectorField
(
ensightFile&,
const List<scalar>& field0,
const List<scalar>& field1,
const List<scalar>& field2,
const bool useFaceData = false,
const bool perNode = false
) const;
//- Write generalized volume field components
template<class Type>
void writeField

59
src/dummyThirdParty/metisDecomp/metis.h vendored
View File

@ -1,5 +1,5 @@
#ifndef METIS_H
#define METIS_H 1
#define METIS_H
/* *** DUMMY VERSION of metis.h - this file should not be included if you have metis
* installed in the correct position in $WM_THIRD_PARTY_DIR - see
@ -8,39 +8,52 @@
#warning "Dummy metis.h - gets included since it cannot find metis installation."
#define IDXTYPEWIDTH 32
// Integer type: OpenFOAM uses WM_LABEL_SIZE, metis.h uses IDXTYPEWIDTH
#if WM_LABEL_SIZE == 32
typedef int32_t idx_t;
/*------------------------------------------------------------------------
* Undefine the following #define in order to use short idxtype as the idxtype
*-------------------------------------------------------------------------*/
#if IDXTYPEWIDTH == 32
#define IDXTYPEWIDTH 32
#define SCNIDX SCNd32
#define PRIIDX PRId32
#elif WM_LABEL_SIZE == 64
typedef int64_t idx_t;
typedef int32_t idxtype;
#elif IDXTYPEWIDTH == 64
#define IDXTYPEWIDTH 64
#define SCNIDX SCNd64
#define PRIIDX PRId64
typedef int64_t idxtype;
#else
#error "Incorrect user-supplied value fo IDXTYPEWIDTH"
#error "Incorrect user-supplied value for WM_LABEL_SIZE (metis IDXTYPEWIDTH)"
#endif
void METIS_WPartGraphRecursive(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt,
idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts,
idxtype *options, idxtype *edgecut, idxtype *part);
void METIS_PartGraphRecursive(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt,
idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options,
idxtype *edgecut, idxtype *part);
void METIS_WPartGraphKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt,
idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts,
idxtype *options, idxtype *edgecut, idxtype *part);
void METIS_PartGraphKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt,
idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options,
idxtype *edgecut, idxtype *part);
// Float type: OpenFOAM uses WM_SP, WM_DP, metis.h uses REALTYPEWIDTH
#if defined(WM_SP)
typedef float real_t;
#define REALTYPEWIDTH 32
#elif defined(WM_DP)
typedef double real_t;
#define REALTYPEWIDTH 64
#else
#error "Incorrect user-supplied value for WM_SP / WM_DP (metis REALTYPEWIDTH)"
#endif
#ifdef __cplusplus
extern "C" {
#endif
int METIS_PartGraphRecursive(idx_t *nvtxs, idx_t *ncon, idx_t *xadj,
idx_t *adjncy, idx_t *vwgt, idx_t *vsize, idx_t *adjwgt,
idx_t *nparts, real_t *tpwgts, real_t *ubvec, idx_t *options,
idx_t *edgecut, idx_t *part);
int METIS_PartGraphKway(idx_t *nvtxs, idx_t *ncon, idx_t *xadj,
idx_t *adjncy, idx_t *vwgt, idx_t *vsize, idx_t *adjwgt,
idx_t *nparts, real_t *tpwgts, real_t *ubvec, idx_t *options,
idx_t *edgecut, idx_t *part);
#ifdef __cplusplus
}
#endif
#endif

3
src/functionObjects/field/Make/files
View File

@ -72,4 +72,7 @@ externalCoupled/externalCoupled.C
externalCoupled/externalCoupledMixed/externalCoupledMixedFvPatchFields.C
externalCoupled/externalCoupledTemperatureMixed/externalCoupledTemperatureMixedFvPatchScalarField.C
ddt2/ddt2.C
zeroGradient/zeroGradient.C
LIB = $(FOAM_LIBBIN)/libfieldFunctionObjects

269
src/functionObjects/field/ddt2/ddt2.C Normal file
View File

@ -0,0 +1,269 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 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 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 "ddt2.H"
#include "volFields.H"
#include "dictionary.H"
#include "FieldFunctions.H"
#include "steadyStateDdtScheme.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace functionObjects
{
defineTypeNameAndDebug(ddt2, 0);
addToRunTimeSelectionTable
(
functionObject,
ddt2,
dictionary
);
}
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
bool Foam::functionObjects::ddt2::checkFormatName(const word& str)
{
if (str.find("@@") == string::npos)
{
WarningInFunction
<< "Bad result naming "
<< "(no '@@' token found), deactivating."
<< nl << endl;
return false;
}
else if (str == "@@")
{
WarningInFunction
<< "Bad result naming "
<< "(only a '@@' token found), deactivating."
<< nl
<< endl;
return false;
}
else
{
return true;
}
}
void Foam::functionObjects::ddt2::uniqWords(wordReList& lst)
{
boolList retain(lst.size());
wordHashSet uniq;
forAll(lst, i)
{
const wordRe& select = lst[i];
retain[i] =
(
select.isPattern()
|| uniq.insert(static_cast<const word&>(select))
);
}
inplaceSubset(retain, lst);
}
bool Foam::functionObjects::ddt2::accept(const word& fieldName) const
{
// check input vs possible result names
// to avoid circular calculations
return !blacklist_.match(fieldName);
}
int Foam::functionObjects::ddt2::process(const word& fieldName)
{
if (!accept(fieldName))
{
return -1;
}
int state = 0;
apply<volScalarField>(fieldName, state);
apply<volVectorField>(fieldName, state);
return state;
}
void Foam::functionObjects::ddt2::process()
{
results_.clear();
wordHashSet candidates = subsetStrings(selectFields_, mesh_.names());
DynamicList<word> missing(selectFields_.size());
DynamicList<word> ignored(selectFields_.size());
// check exact matches first
forAll(selectFields_, i)
{
const wordRe& select = selectFields_[i];
if (!select.isPattern())
{
const word& fieldName = static_cast<const word&>(select);
if (!candidates.erase(fieldName))
{
missing.append(fieldName);
}
else if (process(fieldName) < 1)
{
ignored.append(fieldName);
}
}
}
forAllConstIter(wordHashSet, candidates, iter)
{
process(iter.key());
}
if (missing.size())
{
WarningInFunction
<< "Missing field " << missing << endl;
}
if (ignored.size())
{
WarningInFunction
<< "Unprocessed field " << ignored << endl;
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::functionObjects::ddt2::ddt2
(
const word& name,
const Time& runTime,
const dictionary& dict
)
:
fvMeshFunctionObject(name, runTime, dict),
selectFields_(),
resultName_(word::null),
blacklist_(),
results_(),
mag_(dict.lookupOrDefault<Switch>("mag", false))
{
read(dict);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::functionObjects::ddt2::~ddt2()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool Foam::functionObjects::ddt2::read(const dictionary& dict)
{
if (word(mesh_.ddtScheme("default")) == "steadyState")
{
WarningInFunction
<< typeName << " function object not appropriate for steady-state"
<< endl;
return false;
}
dict.lookup("fields") >> selectFields_;
uniqWords(selectFields_);
resultName_ = dict.lookupOrDefault<word>
(
"result",
( mag_ ? "mag(ddt(@@))" : "magSqr(ddt(@@))" )
);
if (checkFormatName(resultName_))
{
blacklist_.set
(
string::quotemeta<regExp>
(
resultName_
).replace("@@", "(.+)")
);
return true;
}
else
{
blacklist_.clear();
return false;
}
}
bool Foam::functionObjects::ddt2::execute()
{
results_.clear();
process();
return true;
}
bool Foam::functionObjects::ddt2::write()
{
// Consistent output order
const wordList outputList = results_.sortedToc();
forAll(outputList, i)
{
const word& fieldName = outputList[i];
if (foundObject<regIOobject>(fieldName))
{
const regIOobject& io = lookupObject<regIOobject>(fieldName);
Log << type() << " " << name()
<< " write: writing field " << fieldName << endl;
io.write();
}
}
return true;
}
// ************************************************************************* //

200
src/functionObjects/field/ddt2/ddt2.H Normal file
View File

@ -0,0 +1,200 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 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 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/>.
Class
Foam::ddt2
Group
grpFVFunctionObjects
Description
This function object calculates the magnitude squared
of d(scalarField)/dt.
The result can be used further for determining variance or RMS values
(for example).
Example of function object specification:
\verbatim
dpdt2
{
type ddt2;
libs ("libfieldFunctionObjects.so");
fields (p);
result d@@dt2;
...
}
\endverbatim
\heading Function object usage
\table
Property | Description | Required | Default value
type | type name: ddt2 | yes |
fields | Name of fields to process | yes |
result | Name of results | no | magSqr(ddt(@@))
log | Log to standard output | no | yes
mag | Use 'mag' instead of 'magSqr' | no | false
\endtable
Note that the optional 'mag' entry cannot be changed during the simulation
since it alters the dimensions of the output field.
A list of fields can contain exact names or regular expressions.
The token '\@\@' in the result name is replaced by the name of the source
field.
The function object will skip over fields that appear to have
already been processed (ie, their names are similar to the output names).
SourceFiles
ddt2.C
IOddt2.H
\*---------------------------------------------------------------------------*/
#ifndef functionObjects_ddt2_H
#define functionObjects_ddt2_H
#include "fvMeshFunctionObject.H"
#include "volFieldsFwd.H"
#include "OFstream.H"
#include "wordReList.H"
#include "regExp.H"
#include "HashSet.H"
#include "Switch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace functionObjects
{
/*---------------------------------------------------------------------------*\
Class ddt2 Declaration
\*---------------------------------------------------------------------------*/
class ddt2
:
public fvMeshFunctionObject
{
// Private data
//- Name of fields to process
wordReList selectFields_;
//- Formatting for the result fields.
word resultName_;
//- Avoid processing the same field twice.
mutable regExp blacklist_;
//- Hashed names of result fields.
wordHashSet results_;
//- Use 'mag' instead of 'magSqr'.
// Cannot be adjusted during the simulation since it alters the
// dimensions of the output field.
const Switch mag_;
// Private Member Functions
//- Check that the word contains the appropriate substitution token(s).
static bool checkFormatName(const word&);
//- Eliminate duplicate 'word' entries
static void uniqWords(wordReList&);
//- Accept unless field name appears to have already been processed
bool accept(const word& fieldName) const;
//- Apply for the volume field type
template<class FieldType>
int apply(const word& inputName, int& state);
//- Process by trying to apply for various volume field types.
int process(const word& inputName);
//- Calculate the ddt2 fields
void process();
//- Disallow default bitwise copy construct
ddt2(const ddt2&) = delete;
//- Disallow default bitwise assignment
void operator=(const ddt2&) = delete;
public:
//- Runtime type information
TypeName("ddt2");
// Constructors
//- Construct from Time and dictionary
ddt2
(
const word& name,
const Time& runTime,
const dictionary& dict
);
//- Destructor
virtual ~ddt2();
// Member Functions
//- Return name of the ddt2 function object
virtual bool read(const dictionary&);
//- Calculate the ddt2 fields
virtual bool execute();
//- Write the ddt fields
virtual bool write();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace functionObjects
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "ddt2Templates.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

103
src/functionObjects/field/ddt2/ddt2Templates.C Normal file
View File

@ -0,0 +1,103 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 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 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 "Time.H"
#include "dimensionedType.H"
#include "fvcDdt.H"
template<class FieldType>
int Foam::functionObjects::ddt2::apply(const word& inputName, int& state)
{
// State: return 0 (not-processed), -1 (skip), +1 ok
// Already done, or not available
if (state || !foundObject<FieldType>(inputName))
{
return state;
}
const FieldType& input = lookupObject<FieldType>(inputName);
word outputName(resultName_);
outputName.replace("@@", inputName);
results_.set(outputName);
if (!foundObject<volScalarField>(outputName))
{
tmp<volScalarField> tddt2
(
new volScalarField
(
IOobject
(
outputName,
time_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh_,
dimensionedScalar
(
"0",
(
mag_
? mag(input.dimensions()/dimTime)
: magSqr(input.dimensions()/dimTime)
),
Zero
)
)
);
store(outputName, tddt2);
}
volScalarField& output = const_cast<volScalarField&>
(
lookupObject<volScalarField>(outputName)
);
if (mag_)
{
output = mag(fvc::ddt(input));
}
else
{
output = magSqr(fvc::ddt(input));
}
// Could add additional statistics here
Log << type() << " " << name()
<< " field " << outputName
<< " average: " << gAverage(output) << endl;
state = +1;
return state;
}
// ************************************************************************* //

223
src/functionObjects/field/zeroGradient/zeroGradient.C Normal file
View File

@ -0,0 +1,223 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 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 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 "zeroGradient.H"
#include "volFields.H"
#include "dictionary.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace functionObjects
{
defineTypeNameAndDebug(zeroGradient, 0);
addToRunTimeSelectionTable
(
functionObject,
zeroGradient,
dictionary
);
}
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
bool Foam::functionObjects::zeroGradient::checkFormatName(const word& str)
{
if (str.find("@@") == string::npos)
{
WarningInFunction
<< "Bad result naming "
<< "(no '@@' token found), deactivating."
<< nl << endl;
return false;
}
else if (str == "@@")
{
WarningInFunction
<< "Bad result naming "
<< "(only a '@@' token found), deactivating."
<< nl
<< endl;
return false;
}
else
{
return true;
}
}
void Foam::functionObjects::zeroGradient::uniqWords(wordReList& lst)
{
boolList retain(lst.size());
wordHashSet uniq;
forAll(lst, i)
{
const wordRe& select = lst[i];
retain[i] =
(
select.isPattern()
|| uniq.insert(static_cast<const word&>(select))
);
}
inplaceSubset(retain, lst);
}
int Foam::functionObjects::zeroGradient::process(const word& fieldName)
{
int state = 0;
apply<scalar>(fieldName, state);
apply<vector>(fieldName, state);
apply<sphericalTensor>(fieldName, state);
apply<symmTensor>(fieldName, state);
apply<tensor>(fieldName, state);
return state;
}
void Foam::functionObjects::zeroGradient::process()
{
results_.clear();
wordHashSet candidates = subsetStrings(selectFields_, mesh_.names());
DynamicList<word> missing(selectFields_.size());
DynamicList<word> ignored(selectFields_.size());
// check exact matches first
forAll(selectFields_, i)
{
const wordRe& select = selectFields_[i];
if (!select.isPattern())
{
const word& fieldName = static_cast<const word&>(select);
if (!candidates.erase(fieldName))
{
missing.append(fieldName);
}
else if (process(fieldName) < 1)
{
ignored.append(fieldName);
}
}
}
forAllConstIter(wordHashSet, candidates, iter)
{
process(iter.key());
}
if (missing.size())
{
WarningInFunction
<< "Missing field " << missing << endl;
}
if (ignored.size())
{
WarningInFunction
<< "Unprocessed field " << ignored << endl;
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::functionObjects::zeroGradient::zeroGradient
(
const word& name,
const Time& runTime,
const dictionary& dict
)
:
fvMeshFunctionObject(name, runTime, dict),
selectFields_(),
resultName_(string::null),
results_()
{
read(dict);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::functionObjects::zeroGradient::~zeroGradient()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool Foam::functionObjects::zeroGradient::read(const dictionary& dict)
{
dict.lookup("fields") >> selectFields_;
uniqWords(selectFields_);
resultName_ = dict.lookupOrDefault<word>("result", type() + "(@@)");
return checkFormatName(resultName_);
}
bool Foam::functionObjects::zeroGradient::execute()
{
results_.clear();
return true;
}
bool Foam::functionObjects::zeroGradient::write()
{
// Consistent output order
const wordList outputList = results_.sortedToc();
forAll(outputList, i)
{
const word& fieldName = outputList[i];
if (foundObject<regIOobject>(fieldName))
{
const regIOobject& io = lookupObject<regIOobject>(fieldName);
Log << type() << " " << name()
<< " write: writing field " << fieldName << endl;
io.write();
}
}
return true;
}
// ************************************************************************* //

188
src/functionObjects/field/zeroGradient/zeroGradient.H Normal file
View File

@ -0,0 +1,188 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 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 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/>.
Class
Foam::zeroGradient
Group
grpFVFunctionObjects
Description
This function object creates a volume field with zero-gradient
boundary conditions from another volume field.
The result can be used, for example, to post-process near-wall
field values.
Example of function object specification:
\verbatim
zeroGrad
{
type zeroGradient;
libs ("libfieldFunctionObjects.so");
fields (U "(T|k|epsilon|omega)");
result @@nearWall;
...
}
\endverbatim
\heading Function object usage
\table
Property | Description | Required | Default value
type | type name: zeroGradient | yes |
fields | Name of fields to process | yes |
result | Name of results | no | zeroGradient(@@)
log | Log to standard output | no | no
\endtable
A list of fields can contain exact names or regular expressions.
The token '\@\@' in the result name is replaced by the name of the source
field.
The function object will skip over fields that would not benefit
- ie, only processor, empty, zeroGradient, symmetry patches.
This check should also prevent processing fields multiple times.
SourceFiles
zeroGradient.C
zeroGradientFunctionObject.C
IOzeroGradient.H
\*---------------------------------------------------------------------------*/
#ifndef functionObjects_zeroGradient_H
#define functionObjects_zeroGradient_H
#include "fvMeshFunctionObject.H"
#include "volFieldsFwd.H"
#include "OFstream.H"
#include "wordReList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace functionObjects
{
/*---------------------------------------------------------------------------*\
Class zeroGradient Declaration
\*---------------------------------------------------------------------------*/
class zeroGradient
:
public fvMeshFunctionObject
{
// Private data
//- Name of fields to process
wordReList selectFields_;
//- Formatting for the result fields.
word resultName_;
//- Hashed names of result fields, and their type
HashTable<word> results_;
// Private Member Functions
//- Check that the word contains the appropriate substitution token(s).
static bool checkFormatName(const word&);
//- Eliminate duplicate 'word' entries
static void uniqWords(wordReList&);
//- Accept unless field only has empty/zero-gradient/processor patches
template<class Type>
static bool accept(const GeometricField<Type, fvPatchField, volMesh>&);
//- Apply for the volume field type
template<class Type>
int apply(const word& inputName, int& state);
//- Process by trying to apply for various volume field types.
int process(const word& inputName);
//- Calculate the zeroGradient fields
void process();
//- Disallow default bitwise copy construct
zeroGradient(const zeroGradient&) = delete;
//- Disallow default bitwise assignment
void operator=(const zeroGradient&) = delete;
public:
//- Runtime type information
TypeName("zeroGradient");
// Constructors
//- Construct from Time and dictionary
zeroGradient
(
const word& name,
const Time& runTime,
const dictionary& dict
);
//- Destructor
virtual ~zeroGradient();
// Member Functions
//- Read the zeroGradient specification
virtual bool read(const dictionary& dict);
//- Calculate the zeroGradient fields
virtual bool execute();
//- Write the zeroGradient fields
virtual bool write();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace functionObjects
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "zeroGradientTemplates.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

115
src/functionObjects/field/zeroGradient/zeroGradientTemplates.C Normal file
View File

@ -0,0 +1,115 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 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 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 "polyPatch.H"
#include "Time.H"
#include "zeroGradientFvPatchField.H"
template<class Type>
bool Foam::functionObjects::zeroGradient::accept
(
const GeometricField<Type, fvPatchField, volMesh>& input
)
{
const typename GeometricField<Type, fvPatchField, volMesh>::Boundary&
patches = input.boundaryField();
forAll(patches, patchi)
{
const fvPatchField<Type>& p = patches[patchi];
const polyPatch& pp = p.patch().patch();
return !polyPatch::constraintType(pp.type());
}
return false;
}
template<class Type>
int Foam::functionObjects::zeroGradient::apply
(
const word& inputName,
int& state
)
{
typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
// State: return 0 (not-processed), -1 (skip), +1 ok
// Already done, or not available
if (state || !foundObject<VolFieldType>(inputName))
{
return state;
}
const VolFieldType& input = lookupObject<VolFieldType>(inputName);
if (!returnReduce(accept(input), orOp<bool>()))
{
state = -1;
return state;
}
word outputName(resultName_);
outputName.replace("@@", inputName);
// Also save the field-type, just in case we want it later
results_.set(outputName, VolFieldType::typeName);
if (!foundObject<VolFieldType>(outputName))
{
tmp<VolFieldType> tzg
(
new VolFieldType
(
IOobject
(
outputName,
time_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh_,
dimensioned<Type>("0", input.dimensions(), Zero),
zeroGradientFvPatchField<Type>::typeName
)
);
store(outputName, tzg);
}
VolFieldType& output =
const_cast<VolFieldType&>(lookupObject<VolFieldType>(outputName));
output = input;
output.correctBoundaryConditions();
state = +1;
return state;
}
// ************************************************************************* //

2
src/parallel/decompose/metisDecomp/metisDecomp.C
View File

@ -67,7 +67,7 @@ Foam::label Foam::metisDecomp::decompose
// Processor weights initialised with no size, only used if specified in
// a file
Field<floatScalar> processorWeights;
Field<scalar> processorWeights;
// Cell weights (so on the vertices of the dual)
List<label> cellWeights;

20
src/postProcessing/functionObjects/jobControl/Make/files
View File

@ -1,20 +0,0 @@
abortCalculation/abortCalculation.C
abortCalculation/abortCalculationFunctionObject.C
runTimeControl/runTimeControl.C
runTimeControl/runTimeControlFunctionObject.C
runTimeControl/runTimeCondition/runTimeCondition/runTimeCondition.C
runTimeControl/runTimeCondition/runTimeCondition/runTimeConditionNew.C
runTimeControl/runTimeCondition/equationMaxIterCondition/equationMaxIterCondition.C
runTimeControl/runTimeCondition/equationInitialResidualCondition/equationInitialResidualCondition.C
runTimeControl/runTimeCondition/minMaxCondition/minMaxCondition.C
runTimeControl/runTimeCondition/averageCondition/averageCondition.C
runTimeControl/runTimeCondition/minTimeStepCondition/minTimeStepCondition.C
externalCoupled = externalCoupled
$(externalCoupled)/externalCoupledFunctionObject.C
$(externalCoupled)/externalCoupledMixed/externalCoupledMixedFvPatchFields.C
$(externalCoupled)/externalCoupledTemperatureMixed/externalCoupledTemperatureMixedFvPatchScalarField.C
LIB = $(FOAM_LIBBIN)/libjobControl