songtianlun/openfoam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sampledSurface hacking proof-of-concept

Browse Source 
- using 'nil' type to write geometry only, in the future we could fallback to 'null'
  writer and hook in arbitrary formats from surfMesh

- IOobject gets writeEndDivider() static method
This commit is contained in:
Mark Olesen 2009-03-10 13:12:00 +01:00
parent ce3d79de1c
commit 34da731896
25 changed files with 724 additions and 586 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/OpenFOAM/db/IOobject/IOobject.H
View File

@ -359,6 +359,10 @@ public:
template<class Stream>
static inline Stream& writeDivider(Stream& os);
//- Write the standard end file divider
template<class Stream>
static inline Stream& writeEndDivider(Stream& os);
//- Write header
bool writeHeader(Ostream&) const;

9
src/OpenFOAM/db/IOobject/IOobjectI.H
View File

@ -82,5 +82,14 @@ inline Stream& Foam::IOobject::writeDivider(Stream& os)
return os;
}
template<class Stream>
inline Stream& Foam::IOobject::writeEndDivider(Stream& os)
{
os << "\n\n"
"// ************************************************************************* //\n";
return os;
}
// ************************************************************************* //

4
src/OpenFOAM/db/regIOobject/regIOobjectWrite.C
View File

@ -103,9 +103,7 @@ bool Foam::regIOobject::writeObject
return false;
}
os << "\n\n"
"// ************************************************************************* //"
<< endl;
writeEndDivider(os);
osGood = os.good();
}

6
src/conversion/meshReader/meshReaderAux.C
View File

@ -97,10 +97,8 @@ void Foam::meshReader::writeInterfaces(const objectRegistry& registry) const
OFstream os(ioObj.objectPath());
ioObj.writeHeader(os);
os << interfaces_
<< "// *************************************"
<< "************************************ //"
<< endl;
os << interfaces_;
io.writeEndDivider(os);
}

286
src/sampling/sampledSurface/writers/dx/dxSurfaceWriter.C
View File

@ -25,6 +25,7 @@ License
\*---------------------------------------------------------------------------*/
#include "dxSurfaceWriter.H"
#include "fileName.H"
#include "OFstream.H"
#include "faceList.H"
@ -33,12 +34,12 @@ License
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class Type>
void Foam::dxSurfaceWriter<Type>::writeDXGeometry
void Foam::dxSurfaceWriter<Type>::writeGeometry
(
Ostream& os,
const pointField& points,
const faceList& faces,
Ostream& os
) const
const faceList& faces
)
{
// Write vertex coordinates
@ -69,7 +70,7 @@ void Foam::dxSurfaceWriter<Type>::writeDXGeometry
{
FatalErrorIn
(
"writeDXGeometry(Ostream&, const pointField&, const faceList&)"
"writeGeometry(Ostream&, const pointField&, const faceList&)"
) << "Face " << faceI << " vertices " << f
<< " is not a triangle."
<< exit(FatalError);
@ -82,181 +83,137 @@ void Foam::dxSurfaceWriter<Type>::writeDXGeometry
}
// Write scalarField in DX format
template<class Type>
void Foam::dxSurfaceWriter<Type>::writeDXData
(
const pointField& points,
const scalarField& values,
Ostream& os
) const
namespace Foam
{
// Write data
os << "object 3 class array type float rank 0 items "
<< values.size()
<< " data follows" << nl;
forAll(values, elemI)
// Write scalarField in DX format
template<>
void Foam::dxSurfaceWriter<Foam::scalar>::writeData
(
Ostream& os,
const Field<scalar>& values
)
{
os << float(values[elemI]) << nl;
// Write data
os << "object 3 class array type float rank 0 items "
<< values.size() << " data follows" << nl;
forAll(values, elemI)
{
os << float(values[elemI]) << nl;
}
}
if (values.size() == points.size())
// Write vectorField in DX format
template<>
void Foam::dxSurfaceWriter<Foam::vector>::writeData
(
Ostream& os,
const Field<vector>& values
)
{
os << nl << "attribute \"dep\" string \"positions\""
<< nl << nl;
// Write data
os << "object 3 class array type float rank 1 shape 3 items "
<< values.size() << " data follows" << nl;
forAll(values, elemI)
{
os << float(values[elemI].x()) << ' '
<< float(values[elemI].y()) << ' '
<< float(values[elemI].z()) << nl;
}
}
else
// Write sphericalTensorField in DX format
template<>
void Foam::dxSurfaceWriter<Foam::sphericalTensor>::writeData
(
Ostream& os,
const Field<sphericalTensor>& values
)
{
os << nl << "attribute \"dep\" string \"connections\""
<< nl << nl;
// Write data
os << "object 3 class array type float rank 0 items "
<< values.size() << " data follows" << nl;
forAll(values, elemI)
{
os << float(values[elemI][0]) << nl;
}
}
// Write symmTensorField in DX format
template<>
void Foam::dxSurfaceWriter<Foam::symmTensor>::writeData
(
Ostream& os,
const Field<symmTensor>& values
)
{
// Write data
os << "object 3 class array type float rank 2 shape 3 items "
<< values.size() << " data follows" << nl;
forAll(values, elemI)
{
const symmTensor& t = values[elemI];
os << float(t.xx()) << ' ' << float(t.xy()) << ' ' << float(t.xz())
<< float(t.xy()) << ' ' << float(t.yy()) << ' ' << float(t.yz())
<< float(t.xz()) << ' ' << float(t.yz()) << ' ' << float(t.zz())
<< nl;
}
}
// Write tensorField in DX format
template<>
void Foam::dxSurfaceWriter<Foam::tensor>::writeData
(
Ostream& os,
const Field<tensor>& values
)
{
// Write data
os << "object 3 class array type float rank 2 shape 3 items "
<< values.size() << " data follows" << nl;
forAll(values, elemI)
{
const tensor& t = values[elemI];
os << float(t.xx()) << ' ' << float(t.xy()) << ' ' << float(t.xz())
<< float(t.yx()) << ' ' << float(t.yy()) << ' ' << float(t.yz())
<< float(t.zx()) << ' ' << float(t.zy()) << ' ' << float(t.zz())
<< nl;
}
}
}
// Write vectorField in DX format
template<class Type>
void Foam::dxSurfaceWriter<Type>::writeDXData
(
const pointField& points,
const vectorField& values,
Ostream& os
) const
{
// Write data
os << "object 3 class array type float rank 1 shape 3 items "
<< values.size()
<< " data follows" << nl;
forAll(values, elemI)
{
os << float(values[elemI].x()) << ' '
<< float(values[elemI].y()) << ' '
<< float(values[elemI].z()) << nl;
}
if (values.size() == points.size())
{
os << nl << "attribute \"dep\" string \"positions\""
<< nl << nl;
}
else
{
os << nl << "attribute \"dep\" string \"connections\""
<< nl << nl;
}
}
// Write sphericalTensorField in DX format
template<class Type>
void Foam::dxSurfaceWriter<Type>::writeDXData
(
const pointField& points,
const sphericalTensorField& values,
Ostream& os
) const
{
// Write data
os << "object 3 class array type float rank 0 items "
<< values.size()
<< " data follows" << nl;
forAll(values, elemI)
{
os << float(values[elemI][0]) << nl;
}
if (values.size() == points.size())
{
os << nl << "attribute \"dep\" string \"positions\""
<< nl << nl;
}
else
{
os << nl << "attribute \"dep\" string \"connections\""
<< nl << nl;
}
}
// Write symmTensorField in DX format
template<class Type>
void Foam::dxSurfaceWriter<Type>::writeDXData
(
const pointField& points,
const symmTensorField& values,
Ostream& os
) const
{
// Write data
os << "object 3 class array type float rank 2 shape 3 items "
<< values.size()
<< " data follows" << nl;
forAll(values, elemI)
{
const symmTensor& t = values[elemI];
os << float(t.xx()) << ' ' << float(t.xy()) << ' ' << float(t.xz())
<< float(t.xy()) << ' ' << float(t.yy()) << ' ' << float(t.yz())
<< float(t.xz()) << ' ' << float(t.yz()) << ' ' << float(t.zz())
<< nl;
}
if (values.size() == points.size())
{
os << nl << "attribute \"dep\" string \"positions\""
<< nl << nl;
}
else
{
os << nl << "attribute \"dep\" string \"connections\""
<< nl << nl;
}
}
// Write tensorField in DX format
template<class Type>
void Foam::dxSurfaceWriter<Type>::writeDXData
void Foam::dxSurfaceWriter<Type>::writeData
(
const pointField& points,
const tensorField& values,
Ostream& os
) const
Ostream& os,
const Field<Type>& values
)
{
// Write data
os << "object 3 class array type float rank 2 shape 3 items "
<< values.size()
<< " data follows" << nl;
os << "object 3 class array type float rank 0 items "
<< values.size() << " data follows" << nl;
forAll(values, elemI)
{
const tensor& t = values[elemI];
os << float(t.xx()) << ' ' << float(t.xy()) << ' ' << float(t.xz())
<< float(t.yx()) << ' ' << float(t.yy()) << ' ' << float(t.yz())
<< float(t.zx()) << ' ' << float(t.zy()) << ' ' << float(t.zz())
<< nl;
}
if (values.size() == points.size())
{
os << nl << "attribute \"dep\" string \"positions\""
<< nl << nl;
}
else
{
os << nl << "attribute \"dep\" string \"connections\""
<< nl << nl;
os << float(0.0) << nl;
}
}
// Write trailer in DX format
template<class Type>
void Foam::dxSurfaceWriter<Type>::writeDXTrailer(Ostream& os) const
void Foam::dxSurfaceWriter<Type>::writeTrailer(Ostream& os)
{
os << "# the field, with three components: \"positions\","
<< " \"connections\", and \"data\"" << nl
@ -316,11 +273,22 @@ void Foam::dxSurfaceWriter<Type>::write
OFstream os(fName);
writeDXGeometry(points, faces, os);
writeGeometry(os, points, faces);
writeDXData(points, values, os);
writeData(os, values);
writeDXTrailer(os);
if (values.size() == points.size())
{
os << nl << "attribute \"dep\" string \"positions\""
<< nl << nl;
}
else
{
os << nl << "attribute \"dep\" string \"connections\""
<< nl << nl;
}
writeTrailer(os);
os << "end" << nl;
}

44
src/sampling/sampledSurface/writers/dx/dxSurfaceWriter.H
View File

@ -54,49 +54,11 @@ class dxSurfaceWriter
// Private Member Functions
void writeDXGeometry
(
const pointField& points,
const faceList& faces,
Ostream& os
) const;
static void writeGeometry(Ostream&, const pointField&, const faceList&);
void writeDXData
(
const pointField& points,
const scalarField& values,
Ostream& os
) const;
static void writeData(Ostream&, const Field<Type>& values);
void writeDXData
(
const pointField& points,
const vectorField& values,
Ostream& os
) const;
void writeDXData
(
const pointField& points,
const sphericalTensorField& values,
Ostream& os
) const;
void writeDXData
(
const pointField& points,
const symmTensorField& values,
Ostream& os
) const;
void writeDXData
(
const pointField& points,
const tensorField& values,
Ostream& os
) const;
void writeDXTrailer(Ostream& os) const;
static void writeTrailer(Ostream&);
public:

38
src/sampling/sampledSurface/writers/foamFile/foamFileSurfaceWriter.C
View File

@ -25,6 +25,7 @@ License
\*---------------------------------------------------------------------------*/
#include "foamFileSurfaceWriter.H"
#include "fileName.H"
#include "OFstream.H"
#include "faceList.H"
@ -48,6 +49,43 @@ Foam::foamFileSurfaceWriter<Type>::~foamFileSurfaceWriter()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
namespace Foam
{
template<>
void Foam::foamFileSurfaceWriter<Foam::nil>::write
(
const fileName& samplePath,
const fileName& timeDir,
const fileName& surfaceName,
const pointField& points,
const faceList& faces,
const fileName& fieldName,
const Field<Foam::nil>& values,
const bool verbose
) const
{
fileName surfaceDir(samplePath/timeDir/surfaceName);
if (!isDir(surfaceDir))
{
mkDir(surfaceDir);
}
if (verbose)
{
Info<< "Writing nil to " << surfaceDir << endl;
}
// Points
OFstream(surfaceDir/"points")() << points;
// Faces
OFstream(surfaceDir/"faces")() << faces;
}
}
template<class Type>
void Foam::foamFileSurfaceWriter<Type>::write
(

1
src/sampling/sampledSurface/writers/foamFile/foamFileSurfaceWriterRunTime.C
View File

@ -35,6 +35,7 @@ namespace Foam
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makeSurfaceWriterType(foamFileSurfaceWriter, nil);
makeSurfaceWriters(foamFileSurfaceWriter);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

1
src/sampling/sampledSurface/writers/null/nullSurfaceWriterRunTime.C
View File

@ -35,6 +35,7 @@ namespace Foam
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makeSurfaceWriterType(nullSurfaceWriter, nil);
makeSurfaceWriters(nullSurfaceWriter);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

75
src/sampling/sampledSurface/writers/obj/objSurfaceWriter.C
View File

@ -25,6 +25,7 @@ License
\*---------------------------------------------------------------------------*/
#include "objSurfaceWriter.H"
#include "fileName.H"
#include "OFstream.H"
#include "faceList.H"
@ -48,6 +49,80 @@ Foam::objSurfaceWriter<Type>::~objSurfaceWriter()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
namespace Foam
{
template<>
void Foam::objSurfaceWriter<Foam::nil>::write
(
const fileName& samplePath,
const fileName& timeDir,
const fileName& surfaceName,
const pointField& points,
const faceList& faces,
const fileName& fieldName,
const Field<Foam::nil>& values,
const bool verbose
) const
{
fileName surfaceDir(samplePath/timeDir);
if (!isDir(surfaceDir))
{
mkDir(surfaceDir);
}
fileName fName(surfaceDir/surfaceName + ".obj");
if (verbose)
{
Info<< "Writing nil to " << fName << endl;
}
// this is a quick hack
OFstream os(fName);
os << "# Wavefront OBJ file" << nl
<< "o " << os.name().lessExt().name() << nl
<< nl
<< "# points : " << points.size() << nl
<< "# faces : " << faces.size() << nl
<< "# no zones " << nl;
os << nl
<< "# <points count=\"" << points.size() << "\">" << endl;
// Write vertex coords
forAll(points, ptI)
{
os << "v " << points[ptI].x()
<< ' ' << points[ptI].y()
<< ' ' << points[ptI].z() << nl;
}
os << "# </points>" << nl
<< nl
<< "# <faces count=\"" << faces.size() << "\">" << endl;
forAll(faces, i)
{
const face& f = faces[i];
os << 'f';
forAll(f, fp)
{
os << ' ' << f[fp] + 1;
}
os << nl;
}
os << "# </faces>" << endl;
}
}
template<class Type>
void Foam::objSurfaceWriter<Type>::write
(

1
src/sampling/sampledSurface/writers/obj/objSurfaceWriterRunTime.C
View File

@ -35,6 +35,7 @@ namespace Foam
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makeSurfaceWriterType(objSurfaceWriter, nil);
makeSurfaceWriters(objSurfaceWriter);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

257
src/sampling/sampledSurface/writers/raw/rawSurfaceWriter.C
View File

@ -25,6 +25,7 @@ License
\*---------------------------------------------------------------------------*/
#include "rawSurfaceWriter.H"
#include "fileName.H"
#include "OFstream.H"
#include "faceList.H"
@ -37,9 +38,9 @@ template<class Type>
void Foam::rawSurfaceWriter<Type>::writeGeometry
(
const pointField& points,
const label& pointI,
const label pointI,
Ostream& os
) const
)
{
const point& pt = points[pointI];
@ -52,15 +53,16 @@ void Foam::rawSurfaceWriter<Type>::writeGeometry
(
const pointField& points,
const faceList& faces,
const label& faceI,
const label faceI,
Ostream& os
) const
)
{
const point& ct = faces[faceI].centre(points);
os << ct.x() << ' ' << ct.y() << ' ' << ct.z() << ' ';
}
// Write scalarField in raw format
template<class Type>
void Foam::rawSurfaceWriter<Type>::writeData
@ -70,38 +72,29 @@ void Foam::rawSurfaceWriter<Type>::writeData
const faceList& faces,
const scalarField& values,
Ostream& os
) const
)
{
// header
os << "# " << fieldName;
os << "# x y z " << fieldName << endl;
// Write data
if (values.size() == points.size())
{
os << " POINT_DATA " << values.size()
<< nl;
forAll(values, elemI)
{
writeGeometry(points, elemI, os);
os << values[elemI] << nl;
}
}
else
{
os << " FACE_DATA " << values.size()
<< nl;
}
os << "# x y z " << fieldName
<< endl;
// Write data
forAll(values, elemI)
{
if (values.size() == points.size())
{
writeGeometry(points, elemI, os);
}
else
forAll(values, elemI)
{
writeGeometry(points, faces, elemI, os);
os << values[elemI] << nl;
}
os << values[elemI] << endl;
}
os << nl;
}
@ -115,22 +108,9 @@ void Foam::rawSurfaceWriter<Type>::writeData
const faceList& faces,
const vectorField& values,
Ostream& os
) const
)
{
// header
os << "# " << fieldName;
if (values.size() == points.size())
{
os << " POINT_DATA " << values.size()
<< nl;
}
else
{
os << " FACE_DATA " << values.size()
<< nl;
}
os << "# x y z "
<< fieldName << "_x "
<< fieldName << "_y "
@ -138,21 +118,27 @@ void Foam::rawSurfaceWriter<Type>::writeData
<< endl;
// Write data
forAll(values, elemI)
if (values.size() == points.size())
{
const vector& v = values[elemI];
if (values.size() == points.size())
forAll(values, elemI)
{
writeGeometry(points, elemI, os);
const vector& v = values[elemI];
os << v[0] << ' ' << v[1] << ' ' << v[2] << nl;
}
else
}
else
{
forAll(values, elemI)
{
writeGeometry(points, faces, elemI, os);
}
os << v[0] << ' ' << v[1] << ' ' << v[2] << nl;
const vector& v = values[elemI];
os << v[0] << ' ' << v[1] << ' ' << v[2] << nl;
}
}
}
@ -165,40 +151,32 @@ void Foam::rawSurfaceWriter<Type>::writeData
const faceList& faces,
const sphericalTensorField& values,
Ostream& os
) const
)
{
// header
os << "# " << fieldName;
if (values.size() == points.size())
{
os << " POINT_DATA " << values.size()
<< nl;
}
else
{
os << " FACE_DATA " << values.size()
<< nl;
}
os << "# ii ";
os << fieldName << "_ii" << endl;
// Write data
forAll(values, elemI)
if (values.size() == points.size())
{
const sphericalTensor& v = values[elemI];
if (values.size() == points.size())
forAll(values, elemI)
{
writeGeometry(points, elemI, os);
const sphericalTensor& v = values[elemI];
os << v[0] << nl;
}
else
}
else
{
forAll(values, elemI)
{
writeGeometry(points, faces, elemI, os);
}
os << v[0] << nl;
const sphericalTensor& v = values[elemI];
os << v[0] << nl;
}
}
}
@ -212,22 +190,9 @@ void Foam::rawSurfaceWriter<Type>::writeData
const faceList& faces,
const symmTensorField& values,
Ostream& os
) const
)
{
// header
os << "# " << fieldName;
if (values.size() == points.size())
{
os << " POINT_DATA " << values.size()
<< nl;
}
else
{
os << " FACE_DATA " << values.size()
<< nl;
}
os << "# xx xy xz yy yz ";
for(int i=0; i<6; i++)
{
@ -236,22 +201,31 @@ void Foam::rawSurfaceWriter<Type>::writeData
os << endl;
// Write data
forAll(values, elemI)
if (values.size() == points.size())
{
const symmTensor& v = values[elemI];
if (values.size() == points.size())
forAll(values, elemI)
{
writeGeometry(points, elemI, os);
const symmTensor& v = values[elemI];
os << v[0] << ' ' << v[1] << ' ' << v[2]
<< v[3] << ' ' << v[4] << ' ' << v[5]
<< nl;
}
else
}
else
{
forAll(values, elemI)
{
writeGeometry(points, faces, elemI, os);
}
os << v[0] << ' ' << v[1] << ' ' << v[2]
<< v[3] << ' ' << v[4] << ' ' << v[5]
<< nl;
const symmTensor& v = values[elemI];
os << v[0] << ' ' << v[1] << ' ' << v[2]
<< v[3] << ' ' << v[4] << ' ' << v[5]
<< nl;
}
}
}
@ -265,46 +239,40 @@ void Foam::rawSurfaceWriter<Type>::writeData
const faceList& faces,
const tensorField& values,
Ostream& os
) const
)
{
// header
os << "# " << fieldName;
if (values.size() == points.size())
{
os << " POINT_DATA " << values.size()
<< nl;
}
else
{
os << " FACE_DATA " << values.size()
<< nl;
}
os << "# xx xy xz yx yy yz zx zy zz";
for(int i=0; i<9; i++)
for (int i=0; i<9; ++i)
{
os << fieldName << "_" << i << " ";
}
os << endl;
// Write data
forAll(values, elemI)
if (values.size() == points.size())
{
const tensor& v = values[elemI];
if (values.size() == points.size())
forAll(values, elemI)
{
writeGeometry(points, elemI, os);
const tensor& v = values[elemI];
os << v[0] << ' ' << v[1] << ' ' << v[2]
<< v[3] << ' ' << v[4] << ' ' << v[5]
<< v[6] << ' ' << v[7] << ' ' << v[8] << nl;
}
else
}
else
{
forAll(values, elemI)
{
writeGeometry(points, faces, elemI, os);
}
os << v[0] << ' ' << v[1] << ' ' << v[2]
<< v[3] << ' ' << v[4] << ' ' << v[5]
<< v[6] << ' ' << v[7] << ' ' << v[8] << nl;
const tensor& v = values[elemI];
os << v[0] << ' ' << v[1] << ' ' << v[2]
<< v[3] << ' ' << v[4] << ' ' << v[5]
<< v[6] << ' ' << v[7] << ' ' << v[8] << nl;
}
}
}
@ -327,6 +295,55 @@ Foam::rawSurfaceWriter<Type>::~rawSurfaceWriter()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
namespace Foam
{
template<>
void Foam::rawSurfaceWriter<Foam::nil>::write
(
const fileName& samplePath,
const fileName& timeDir,
const fileName& surfaceName,
const pointField& points,
const faceList& faces,
const fileName& fieldName,
const Field<Foam::nil>& values,
const bool verbose
) const
{
fileName surfaceDir(samplePath/timeDir);
if (!isDir(surfaceDir))
{
mkDir(surfaceDir);
}
fileName fName(surfaceDir/surfaceName + ".raw");
if (verbose)
{
Info<< "Writing nil to " << fName << endl;
}
OFstream os(fName);
// header
os << "# geometry NO_DATA " << faces.size() << nl
<< "# x y z" << endl;
// Write faces
forAll(faces, elemI)
{
writeGeometry(points, faces, elemI, os);
os << nl;
}
os << nl;
}
}
template<class Type>
void Foam::rawSurfaceWriter<Type>::write
(
@ -355,6 +372,20 @@ void Foam::rawSurfaceWriter<Type>::write
}
OFstream os(fName);
// header
os << "# " << fieldName;
if (values.size() == points.size())
{
os << " POINT_DATA ";
}
else
{
os << " FACE_DATA ";
}
os << values.size() << nl;
writeData(fieldName, points, faces, values, os);
}

32
src/sampling/sampledSurface/writers/raw/rawSurfaceWriter.H
View File

@ -53,65 +53,65 @@ class rawSurfaceWriter
{
// Private Member Functions
void writeGeometry
static void writeGeometry
(
const pointField& points,
const label& pointI,
const label pointI,
Ostream& os
) const;
);
void writeGeometry
static void writeGeometry
(
const pointField& points,
const faceList& faces,
const label& faceI,
const label faceI,
Ostream& os
) const;
);
void writeData
static void writeData
(
const fileName& fieldName,
const pointField& points,
const faceList& faces,
const scalarField& values,
Ostream& os
) const;
);
void writeData
static void writeData
(
const fileName& fieldName,
const pointField& points,
const faceList& faces,
const vectorField& values,
Ostream& os
) const;
);
void writeData
static void writeData
(
const fileName& fieldName,
const pointField& points,
const faceList& faces,
const sphericalTensorField& values,
Ostream& os
) const;
);
void writeData
static void writeData
(
const fileName& fieldName,
const pointField& points,
const faceList& faces,
const symmTensorField& values,
Ostream& os
) const;
);
void writeData
static void writeData
(
const fileName& fieldName,
const pointField& points,
const faceList& faces,
const tensorField& values,
Ostream& os
) const;
);
public:

1
src/sampling/sampledSurface/writers/raw/rawSurfaceWriterRunTime.C
View File

@ -35,6 +35,7 @@ namespace Foam
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makeSurfaceWriterType(rawSurfaceWriter, nil);
makeSurfaceWriters(rawSurfaceWriter);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

68
src/sampling/sampledSurface/writers/stl/stlSurfaceWriter.C
View File

@ -49,6 +49,74 @@ Foam::stlSurfaceWriter<Type>::~stlSurfaceWriter()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
namespace Foam
{
template<>
void Foam::stlSurfaceWriter<Foam::nil>::write
(
const fileName& samplePath,
const fileName& timeDir,
const fileName& surfaceName,
const pointField& points,
const faceList& faces,
const fileName& fieldName,
const Field<Foam::nil>& values,
const bool verbose
) const
{
fileName surfaceDir(samplePath/timeDir);
if (!isDir(surfaceDir))
{
mkDir(surfaceDir);
}
fileName fName(surfaceDir/surfaceName + ".stl");
if (verbose)
{
Info<< "Writing nil to " << fName << endl;
}
// Convert faces to triangles.
DynamicList<labelledTri> tris(faces.size());
forAll(faces, i)
{
const face& f = faces[i];
faceList triFaces(f.nTriangles(points));
label nTris = 0;
f.triangles(points, nTris, triFaces);
forAll(triFaces, triI)
{
const face& tri = triFaces[triI];
tris.append(labelledTri(tri[0], tri[1], tri[2], 0));
}
}
triSurface
(
tris.shrink(),
geometricSurfacePatchList
(
1,
geometricSurfacePatch
(
"patch", // geometricType
"patch0", // fieldName
0 // index
)
),
points
).write(fName);
}
}
template<class Type>
void Foam::stlSurfaceWriter<Type>::write
(

1
src/sampling/sampledSurface/writers/stl/stlSurfaceWriterRunTime.C
View File

@ -35,6 +35,7 @@ namespace Foam
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makeSurfaceWriterType(stlSurfaceWriter, nil);
makeSurfaceWriters(stlSurfaceWriter);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

53
src/sampling/sampledSurface/writers/surfaceWriter.C
View File

@ -31,48 +31,61 @@ License
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
template<class Type>
autoPtr<surfaceWriter<Type> > surfaceWriter<Type>::New(const word& writeType)
Foam::autoPtr< Foam::surfaceWriter<Type> >
Foam::surfaceWriter<Type>::New(const word& writeType)
{
typename wordConstructorTable::iterator cstrIter =
wordConstructorTablePtr_
->find(writeType);
wordConstructorTablePtr_->find(writeType);
if (cstrIter == wordConstructorTablePtr_->end())
{
FatalErrorIn
// unknown, check if it can handle Foam::nil specialization
// (ie, geometry write)
// generally supported, but not for this data type
if
(
"surfaceWriter::New(const word&)"
) << "Unknown write type " << writeType
<< endl << endl
<< "Valid write types : " << endl
<< wordConstructorTablePtr_->toc()
<< exit(FatalError);
Foam::surfaceWriter<Foam::nil>::wordConstructorTablePtr_->found
(
writeType
)
)
{
// use 'null' file instead
cstrIter = wordConstructorTablePtr_->find("null");
}
if (cstrIter == wordConstructorTablePtr_->end())
{
FatalErrorIn
(
"surfaceWriter::New(const word&)"
) << "Unknown write type " << writeType
<< endl << endl
<< "Valid write types : " << endl
<< wordConstructorTablePtr_->toc()
<< exit(FatalError);
}
}
return autoPtr<surfaceWriter<Type> >(cstrIter()());
return autoPtr< surfaceWriter<Type> >(cstrIter()());
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
surfaceWriter<Type>::surfaceWriter()
Foam::surfaceWriter<Type>::surfaceWriter()
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type>
surfaceWriter<Type>::~surfaceWriter()
Foam::surfaceWriter<Type>::~surfaceWriter()
{}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

9
src/sampling/sampledSurface/writers/surfaceWriter.H
View File

@ -41,19 +41,26 @@ SourceFiles
#include "autoPtr.H"
#include "pointField.H"
#include "faceList.H"
#include "nil.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of friend functions and operators
template<class Type> class surfaceWriter;
/*---------------------------------------------------------------------------*\
Class surfaceWriter Declaration
Class surfaceWriter Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class surfaceWriter
{
//- friendship between writer data types
template<class Type2> friend class surfaceWriter;
public:

6
src/sampling/sampledSurface/writers/surfaceWriters.C
View File

@ -33,8 +33,10 @@ namespace Foam
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
#define defineSurfaceWriterType(dataType) \
defineNamedTemplateTypeNameAndDebug(surfaceWriter<dataType >, 0); \
defineTemplatedRunTimeSelectionTable(surfaceWriter, word, dataType);
defineNamedTemplateTypeNameAndDebug(surfaceWriter< dataType >, 0); \
defineTemplatedRunTimeSelectionTable(surfaceWriter, word, dataType)
defineSurfaceWriterType(nil);
defineSurfaceWriterType(scalar);
defineSurfaceWriterType(vector);

10
src/sampling/sampledSurface/writers/surfaceWriters.H
View File

@ -39,7 +39,7 @@ Description
// Only used internally
#define makeTypeSurfaceWritersTypeName(typeWriter, dataType) \
\
defineNamedTemplateTypeNameAndDebug(typeWriter<dataType >, 0);
defineNamedTemplateTypeNameAndDebug(typeWriter< dataType >, 0)
// Sometimes used externally
#define makeSurfaceWritersTypeName(typeWriter) \
@ -48,16 +48,16 @@ Description
makeTypeSurfaceWritersTypeName(typeWriter, vector); \
makeTypeSurfaceWritersTypeName(typeWriter, sphericalTensor); \
makeTypeSurfaceWritersTypeName(typeWriter, symmTensor); \
makeTypeSurfaceWritersTypeName(typeWriter, tensor);
makeTypeSurfaceWritersTypeName(typeWriter, tensor)
// Define type info for single dataType template instantiation (eg, vector)
#define makeSurfaceWriterType(typeWriter, dataType) \
\
defineNamedTemplateTypeNameAndDebug(typeWriter<dataType >, 0); \
defineNamedTemplateTypeNameAndDebug(typeWriter< dataType >, 0); \
addTemplatedToRunTimeSelectionTable \
( \
surfaceWriter, typeWriter, dataType, word \
);
)
// Define type info for scalar, vector etc. instantiations
@ -67,7 +67,7 @@ Description
makeSurfaceWriterType(typeWriter, vector); \
makeSurfaceWriterType(typeWriter, sphericalTensor); \
makeSurfaceWriterType(typeWriter, symmTensor); \
makeSurfaceWriterType(typeWriter, tensor);
makeSurfaceWriterType(typeWriter, tensor)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

314
src/sampling/sampledSurface/writers/vtk/vtkSurfaceWriter.C
View File

@ -25,6 +25,7 @@ License
\*---------------------------------------------------------------------------*/
#include "vtkSurfaceWriter.H"
#include "fileName.H"
#include "OFstream.H"
#include "faceList.H"
@ -35,13 +36,12 @@ License
template<class Type>
void Foam::vtkSurfaceWriter<Type>::writeGeometry
(
Ostream& os,
const pointField& points,
const faceList& faces,
Ostream& os
) const
const faceList& faces
)
{
// Write vertex coordinates
// header
os
<< "# vtk DataFile Version 2.0" << nl
<< "sampleSurface" << nl
@ -57,7 +57,7 @@ void Foam::vtkSurfaceWriter<Type>::writeGeometry
<< float(pt.y()) << ' '
<< float(pt.z()) << nl;
}
os << endl;
os << nl;
// Write faces
@ -84,156 +84,117 @@ void Foam::vtkSurfaceWriter<Type>::writeGeometry
}
// Write scalarField in vtk format
template<class Type>
void Foam::vtkSurfaceWriter<Type>::writeData
(
const fileName& fieldName,
const pointField& points,
const scalarField& values,
Ostream& os
) const
namespace Foam
{
// Write data
if (values.size() == points.size())
{
os << "POINT_DATA " << values.size()
<< nl
<< "FIELD attributes 1" << nl;
}
else
{
os << "CELL_DATA " << values.size()
<< nl
<< "FIELD attributes 1" << nl;
}
os << fieldName << " 1 " << values.size() << " float" << nl;
forAll(values, elemI)
// Write scalarField in vtk format
template<>
void Foam::vtkSurfaceWriter<Foam::scalar>::writeData
(
Ostream& os,
const Field<Foam::scalar>& values
)
{
if (elemI)
os << "1 " << values.size() << " float" << nl;
forAll(values, elemI)
{
if (elemI % 10)
if (elemI)
{
os << ' ';
}
else
{
os << nl;
if (elemI % 10)
{
os << ' ';
}
else
{
os << nl;
}
}
const scalar& v = values[elemI];
os << float(v);
}
os << float(values[elemI]);
os << nl;
}
os << nl;
}
// Write vectorField in vtk format
template<class Type>
void Foam::vtkSurfaceWriter<Type>::writeData
(
const fileName& fieldName,
const pointField& points,
const vectorField& values,
Ostream& os
) const
{
// Write data
if (values.size() == points.size())
// Write vectorField in vtk format
template<>
void Foam::vtkSurfaceWriter<Foam::vector>::writeData
(
Ostream& os,
const Field<Foam::vector>& values
)
{
os << "POINT_DATA " << values.size()
<< nl
<< "FIELD attributes 1" << nl;
os << "3 " << values.size() << " float" << nl;
forAll(values, elemI)
{
const vector& v = values[elemI];
os << float(v[0]) << ' ' << float(v[1]) << ' ' << float(v[2])
<< nl;
}
}
else
// Write sphericalTensorField in vtk format
template<>
void Foam::vtkSurfaceWriter<Foam::sphericalTensor>::writeData
(
Ostream& os,
const Field<sphericalTensor>& values
)
{
os << "CELL_DATA " << values.size()
<< nl
<< "FIELD attributes 1" << nl;
os << "1 " << values.size() << " float" << nl;
forAll(values, elemI)
{
const sphericalTensor& v = values[elemI];
os << float(v[0]) << nl;
}
}
os << fieldName << " 3 " << values.size() << " float" << nl;
forAll(values, elemI)
// Write symmTensorField in vtk format
template<>
void Foam::vtkSurfaceWriter<Foam::symmTensor>::writeData
(
Ostream& os,
const Field<symmTensor>& values
)
{
const vector& v = values[elemI];
os << "6 " << values.size() << " float" << nl;
os << float(v[0]) << ' ' << float(v[1]) << ' ' << float(v[2]) << nl;
forAll(values, elemI)
{
const symmTensor& v = values[elemI];
os << float(v[0]) << ' ' << float(v[1]) << ' ' << float(v[2])
<< float(v[3]) << ' ' << float(v[4]) << ' ' << float(v[5])
<< nl;
}
}
}
// Write sphericalTensorField in vtk format
template<class Type>
void Foam::vtkSurfaceWriter<Type>::writeData
(
const fileName& fieldName,
const pointField& points,
const sphericalTensorField& values,
Ostream& os
) const
{
// Write data
if (values.size() == points.size())
// Write tensorField in vtk format
template<>
void Foam::vtkSurfaceWriter<Foam::tensor>::writeData
(
Ostream& os,
const Field<tensor>& values
)
{
os << "POINT_DATA " << values.size()
<< nl
<< "FIELD attributes 1" << nl;
}
else
{
os << "CELL_DATA " << values.size()
<< nl
<< "FIELD attributes 1" << nl;
os << "9 " << values.size() << " float" << nl;
forAll(values, elemI)
{
const tensor& v = values[elemI];
os << float(v[0]) << ' ' << float(v[1]) << ' ' << float(v[2])
<< float(v[3]) << ' ' << float(v[4]) << ' ' << float(v[5])
<< float(v[6]) << ' ' << float(v[7]) << ' ' << float(v[8])
<< nl;
}
}
os << fieldName << " 1 " << values.size() << " float" << nl;
forAll(values, elemI)
{
const sphericalTensor& v = values[elemI];
os << float(v[0])
<< nl;
}
}
// Write symmTensorField in vtk format
template<class Type>
void Foam::vtkSurfaceWriter<Type>::writeData
(
const fileName& fieldName,
const pointField& points,
const symmTensorField& values,
Ostream& os
) const
{
// Write data
if (values.size() == points.size())
{
os << "POINT_DATA " << values.size()
<< nl
<< "FIELD attributes 1" << nl;
}
else
{
os << "CELL_DATA " << values.size()
<< nl
<< "FIELD attributes 1" << nl;
}
os << fieldName << " 6 " << values.size() << " float" << nl;
forAll(values, elemI)
{
const symmTensor& v = values[elemI];
os << float(v[0]) << ' ' << float(v[1]) << ' ' << float(v[2])
<< float(v[3]) << ' ' << float(v[4]) << ' ' << float(v[5])
<< nl;
}
}
@ -241,36 +202,15 @@ void Foam::vtkSurfaceWriter<Type>::writeData
template<class Type>
void Foam::vtkSurfaceWriter<Type>::writeData
(
const fileName& fieldName,
const pointField& points,
const tensorField& values,
Ostream& os
) const
Ostream& os,
const Field<Type>& values
)
{
// Write data
if (values.size() == points.size())
{
os << "POINT_DATA " << values.size()
<< nl
<< "FIELD attributes 1" << nl;
}
else
{
os << "CELL_DATA " << values.size()
<< nl
<< "FIELD attributes 1" << nl;
}
os << fieldName << " 9 " << values.size() << " float" << nl;
os << "1 " << values.size() << " float" << nl;
forAll(values, elemI)
{
const tensor& v = values[elemI];
os << float(v[0]) << ' ' << float(v[1]) << ' ' << float(v[2])
<< float(v[3]) << ' ' << float(v[4]) << ' ' << float(v[5])
<< float(v[6]) << ' ' << float(v[7]) << ' ' << float(v[8])
<< nl;
os << float(0) << nl;
}
}
@ -294,6 +234,42 @@ Foam::vtkSurfaceWriter<Type>::~vtkSurfaceWriter()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
namespace Foam
{
template<>
void Foam::vtkSurfaceWriter<Foam::nil>::write
(
const fileName& samplePath,
const fileName& timeDir,
const fileName& surfaceName,
const pointField& points,
const faceList& faces,
const fileName& fieldName,
const Field<Foam::nil>& values,
const bool verbose
) const
{
fileName surfaceDir(samplePath/timeDir);
if (!isDir(surfaceDir))
{
mkDir(surfaceDir);
}
fileName fName(surfaceDir/surfaceName + ".vtk");
if (verbose)
{
Info<< "Writing nil to " << fName << endl;
}
OFstream os(fName);
writeGeometry(os, points, faces);
}
}
template<class Type>
void Foam::vtkSurfaceWriter<Type>::write
(
@ -322,9 +298,25 @@ void Foam::vtkSurfaceWriter<Type>::write
}
OFstream os(fName);
writeGeometry(os, points, faces);
// start writing data
if (values.size() == points.size())
{
os << "POINT_DATA ";
}
else
{
os << "CELL_DATA ";
}
os << values.size() << nl
<< "FIELD attributes 1" << nl
<< fieldName << " ";
// Write data
writeData(os, values);
writeGeometry(points, faces, os);
writeData(fieldName, points, values, os);
}

47
src/sampling/sampledSurface/writers/vtk/vtkSurfaceWriter.H
View File

@ -53,52 +53,9 @@ class vtkSurfaceWriter
{
// Private Member Functions
void writeGeometry
(
const pointField& points,
const faceList& faces,
Ostream& os
) const;
static void writeGeometry(Ostream&, const pointField&, const faceList&);
void writeData
(
const fileName& fieldName,
const pointField& points,
const scalarField& values,
Ostream& os
) const;
void writeData
(
const fileName& fieldName,
const pointField& points,
const vectorField& values,
Ostream& os
) const;
void writeData
(
const fileName& fieldName,
const pointField& points,
const sphericalTensorField& values,
Ostream& os
) const;
void writeData
(
const fileName& fieldName,
const pointField& points,
const symmTensorField& values,
Ostream& os
) const;
void writeData
(
const fileName& fieldName,
const pointField& points,
const tensorField& values,
Ostream& os
) const;
static void writeData(Ostream&, const Field<Type>& values);
public:

1
src/sampling/sampledSurface/writers/vtk/vtkSurfaceWriterRunTime.C
View File

@ -35,6 +35,7 @@ namespace Foam
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makeSurfaceWriterType(vtkSurfaceWriter, nil);
makeSurfaceWriters(vtkSurfaceWriter);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

34
src/surfMesh/MeshedSurfaceProxy/MeshedSurfaceProxy.C
View File

@ -25,13 +25,13 @@ License
\*---------------------------------------------------------------------------*/
#include "MeshedSurfaceProxy.H"
#include "MeshedSurface.H"
#include "Time.H"
#include "surfMesh.H"
#include "OFstream.H"
#include "ListOps.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
template<class Face>
Foam::wordHashSet Foam::MeshedSurfaceProxy<Face>::writeTypes()
@ -40,8 +40,6 @@ Foam::wordHashSet Foam::MeshedSurfaceProxy<Face>::writeTypes()
}
// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
template<class Face>
bool Foam::MeshedSurfaceProxy<Face>::canWriteType
(
@ -135,13 +133,19 @@ void Foam::MeshedSurfaceProxy<Face>::write
)
);
OFstream os(objectDir/io.name());
OFstream os
(
objectDir/io.name(),
t.writeFormat(),
IOstream::currentVersion,
t.writeCompression()
);
io.writeHeader(os);
os << this->points();
os << "\n\n"
"// ************************************************************************* //\n";
io.writeEndDivider(os);
}
@ -161,7 +165,13 @@ void Foam::MeshedSurfaceProxy<Face>::write
)
);
OFstream os(objectDir/io.name());
OFstream os
(
objectDir/io.name(),
t.writeFormat(),
IOstream::currentVersion,
t.writeCompression()
);
io.writeHeader(os);
if (this->useFaceMap())
@ -174,8 +184,7 @@ void Foam::MeshedSurfaceProxy<Face>::write
os << this->faces();
}
os << "\n\n"
"// ************************************************************************* //\n";
io.writeEndDivider(os);
}
@ -195,14 +204,13 @@ void Foam::MeshedSurfaceProxy<Face>::write
)
);
// write as ascii
OFstream os(objectDir/io.name());
io.writeHeader(os);
os << this->surfZones();
os << "\n\n"
"// ************************************************************************* //"
<< endl;
io.writeEndDivider(os);
}
}

8
src/surfMesh/MeshedSurfaceProxy/MeshedSurfaceProxy.H
View File

@ -83,10 +83,12 @@ public:
// Static
//- Can we write this file format?
//- The file format types that can be written via MeshedSurfaceProxy
static wordHashSet writeTypes();
//- Can this file format type be written via MeshedSurfaceProxy?
static bool canWriteType(const word& ext, const bool verbose=false);
static wordHashSet writeTypes();
// Constructors
@ -95,7 +97,7 @@ public:
(
const pointField&,
const List<Face>&,
const List<surfZone>&,
const List<surfZone>& = List<surfZone>(),
const List<label>& faceMap = List<label>()
);