WriterVTK Class Reference

#include <WriterVTK.hpp>

Inheritance diagram for WriterVTK:

[legend]

Collaboration diagram for WriterVTK:

[legend]

List of all members.

Public Types
typedef std::vector < ConstReferenceCounting < FieldOfScalarFunction > >	FieldList
typedef std::vector < ConstReferenceCounting < ScalarFunctionBase > >	ScalarFunctionList
Public Member Functions
void	proceed () const
	WriterVTK (ConstReferenceCounting< Mesh > mesh, const std::string &filename, const FileDescriptor &fileDescriptor)
	~WriterVTK ()
void	add (ConstReferenceCounting< ScalarFunctionBase > function)
void	add (ConstReferenceCounting< FieldOfScalarFunction > field)
Protected Attributes
ConstReferenceCounting< Mesh >	__mesh
const std::string	__filename
const FileDescriptor &	__fileDescriptor
const std::string	__CR
FieldList	__fieldList
ScalarFunctionList	__scalarFunctionList
Private Member Functions
template<typename MeshType>
void	__proceed () const
	WriterVTK (const WriterVTK &)
void	__fillCrossedComponent (const FieldOfScalarFunction &field, Vector< real_t > &values) const
Private Attributes
const bool	__binary
Classes
struct	Traits
struct	Traits< CartesianHexahedron >
struct	Traits< Hexahedron >
struct	Traits< Quadrangle >
struct	Traits< Tetrahedron >
struct	Traits< Triangle >

---

Detailed Description

Definition at line 33 of file WriterVTK.hpp.

---

Member Typedef Documentation

typedef std::vector<ConstReferenceCounting<FieldOfScalarFunction> > WriterBase::FieldList [inherited]

Definition at line 44 of file WriterBase.hpp.

typedef std::vector<ConstReferenceCounting<ScalarFunctionBase> > WriterBase::ScalarFunctionList [inherited]

Definition at line 45 of file WriterBase.hpp.

---

Constructor & Destructor Documentation

WriterVTK::WriterVTK

(

const WriterVTK &

)

[private]

Copy constructor is forbidden

WriterVTK::WriterVTK	(	ConstReferenceCounting< Mesh >	mesh,
		const std::string &	filename,
		const FileDescriptor &	fileDescriptor
	)

Constructor

Parameters:

	mesh	given mesh
	filename	basename of the VTK file
	fileDescriptor	describes file type

Definition at line 936 of file WriterVTK.cpp.

  : WriterBase(mesh,
               filename,
               fileDescriptor),
    __binary((fileDescriptor.type() == FileDescriptor::binary) or 
             (fileDescriptor.type() == FileDescriptor::formatDefault))
{
  ;
}

WriterVTK::~WriterVTK

(

)

Destructor

Definition at line 949 of file WriterVTK.cpp.

{
  ;
}

---

Member Function Documentation

void WriterVTK::__proceed< Structured3DMesh >

(

)

const [inline, private]

Save data on a specific mesh type

Definition at line 228 of file WriterVTK.cpp.

References __binary, WriterBase::__fieldList, WriterBase::__filename, __fillCrossedComponent(), WriterBase::__mesh, WriterBase::__scalarFunctionList, BinarySerializerVTK::add(), XMLWriter::add(), XMLTag::add(), FEMFunctionBase::baseMesh(), XMLWriter::closeTag(), FEMFunctionBase::discretizationType(), ScalarFunctionBase::femfunction, XMLWriter::insert(), XMLWriter::insertNewLine(), XMLWriter::insertUnderscore(), ScalarDiscretizationTypeBase::lagrangianFEM1, FieldOfScalarFunction::numberOfComponents(), BinarySerializerVTK::offset(), stringify(), ScalarFunctionBase::type(), and XMLWriter::writeHeader().

{
  typedef typename MeshType::CellType CellType;

  std::string filename = __filename;
  filename += ".vtu";

  const MeshType& mesh
    = static_cast<const MeshType&>(*__mesh);

//   size_t surfaceMeshNumberOfCells = 0;
//   if (mesh.hasaceMesh()) {
//     surfaceMeshNumberOfCells = mesh.surfaceMesh()->numberOfCells();
//   }

  std::ofstream file(filename.c_str());
  file.precision(15);

  XMLWriter xmlWriter(file);

  xmlWriter.writeHeader();
  {
    XMLTag vtkFile("VTKFile");
    ReferenceCounting<XMLAttribute> attribute
      = new XMLAttribute("type","UnstructuredGrid");
    vtkFile.add(attribute);

    if (this->__binary) {
      ReferenceCounting<XMLAttribute> endiannes
        = new XMLAttribute("byte_order","LittleEndian");
      vtkFile.add(endiannes);
    }

    xmlWriter.add(vtkFile);
  }

  {
    XMLTag unstructuredGrid("UnstructuredGrid");
    xmlWriter.add(unstructuredGrid);
  }

  {
    XMLTag piece("Piece");
    ReferenceCounting<XMLAttribute>
      nbPoints = new XMLAttribute("NumberOfPoints",
                                  stringify(mesh.numberOfVertices()));
    piece.add(nbPoints);
    ReferenceCounting<XMLAttribute>
      nbCells = new XMLAttribute("NumberOfCells",
                                 stringify(mesh.numberOfCells()));
    piece.add(nbCells);
    xmlWriter.add(piece);

    {
      XMLTag points("Points");
      xmlWriter.add(points);
   
      {  
        XMLTag dataarray("DataArray");
        ReferenceCounting<XMLAttribute>
          type = new XMLAttribute("type","Float64");
        dataarray.add(type);
        ReferenceCounting<XMLAttribute>
          name = new XMLAttribute("Name","Position");
        dataarray.add(name);
        ReferenceCounting<XMLAttribute>
          nbComponent = new XMLAttribute("NumberOfComponents","3");
        dataarray.add(nbComponent);

        if (not this->__binary) {
          ReferenceCounting<XMLAttribute>
            format = new XMLAttribute("format","ascii");
          dataarray.add(format);

          xmlWriter.add(dataarray);

          for (size_t i=0; i<mesh.numberOfVertices(); ++i) {
            const Vertex& x = mesh.vertex(i); 
            xmlWriter.insert(x[0]);
            xmlWriter.insert(x[1]);
            xmlWriter.insert(x[2]);
          }
          xmlWriter.insertNewLine();
          xmlWriter.closeTag();
        } else {
          ReferenceCounting<XMLAttribute>
            format = new XMLAttribute("format","appended");
          dataarray.add(format);

          ReferenceCounting<XMLAttribute>
            offset = new XMLAttribute("offset",stringify(serializer.offset()));
          dataarray.add(offset);

          xmlWriter.add(dataarray);

          Vector<real_t> coords(3*mesh.numberOfVertices());
          for (size_t i=0; i<mesh.numberOfVertices(); ++i) {
            const Vertex& x = mesh.vertex(i); 
            coords[3*i+0] = x[0];
            coords[3*i+1] = x[1];
            coords[3*i+2] = x[2];
          }

          serializer.add(coords);
          xmlWriter.closeTag();
        }
      }
      xmlWriter.closeTag();
    }

    {
      XMLTag cells("Cells");
      xmlWriter.add(cells);

      {
        XMLTag dataarray("DataArray");
        ReferenceCounting<XMLAttribute>
          type = new XMLAttribute("type","Int32");
        dataarray.add(type);
        ReferenceCounting<XMLAttribute>
          name = new XMLAttribute("Name","connectivity");
        dataarray.add(name);
        ReferenceCounting<XMLAttribute>
          nbComponent = new XMLAttribute("NumberOfComponents","1");
        dataarray.add(nbComponent);

        if (not this->__binary) {
          ReferenceCounting<XMLAttribute>
            format = new XMLAttribute("format","ascii");
          dataarray.add(format);
          xmlWriter.add(dataarray);

          for (size_t i=0;i<mesh.numberOfCells(); ++i) {
            const CellType& cell = mesh.cell(i);
            for (size_t j=0; j<CellType::NumberOfVertices; ++j) {
              xmlWriter.insert(mesh.vertexNumber(cell(j)));
            }
          }
          xmlWriter.insertNewLine();
          xmlWriter.closeTag();
        } else {
          ReferenceCounting<XMLAttribute>
            format = new XMLAttribute("format","appended");
          dataarray.add(format);

          ReferenceCounting<XMLAttribute>
            offset = new XMLAttribute("offset",stringify(serializer.offset()));
          dataarray.add(offset);

          Vector<int> cellDescription(CellType::NumberOfVertices*mesh.numberOfCells());

          for (size_t i=0;i<mesh.numberOfCells(); ++i) {
            const CellType& cell = mesh.cell(i);
            for (size_t j=0; j<CellType::NumberOfVertices; ++j) {
              cellDescription[i*CellType::NumberOfVertices+j]
                = mesh.vertexNumber(cell(j));
            }
          }

          serializer.add(cellDescription);

          xmlWriter.add(dataarray);
          xmlWriter.closeTag();
        }
      }

      {
        XMLTag dataarray("DataArray");
        ReferenceCounting<XMLAttribute>
          type = new XMLAttribute("type","Int32");
        dataarray.add(type);
        ReferenceCounting<XMLAttribute>
          name = new XMLAttribute("Name","offsets");
        dataarray.add(name);
        ReferenceCounting<XMLAttribute>
          nbComponent = new XMLAttribute("NumberOfComponents","1");
        dataarray.add(nbComponent);
        if (not this->__binary) {
          ReferenceCounting<XMLAttribute>
            format = new XMLAttribute("format","ascii");
          dataarray.add(format);
          xmlWriter.add(dataarray);
     
          for (size_t i=1; i<=mesh.numberOfCells(); ++i) {
            xmlWriter.insert(i*CellType::NumberOfVertices);
          }

          xmlWriter.insertNewLine();
          xmlWriter.closeTag();      
        } else {
          ReferenceCounting<XMLAttribute>
            format = new XMLAttribute("format","appended");
          dataarray.add(format);

          ReferenceCounting<XMLAttribute>
            offset = new XMLAttribute("offset",stringify(serializer.offset()));
          dataarray.add(offset);

          Vector<int> offsets(mesh.numberOfCells());
          for (size_t i=0; i<mesh.numberOfCells(); ++i) {
            offsets[i] = ((i+1)*CellType::NumberOfVertices);
          }

          serializer.add(offsets);

          xmlWriter.add(dataarray);
          xmlWriter.closeTag();
        }
      }

      {
        XMLTag dataarray("DataArray");
        ReferenceCounting<XMLAttribute>
          type = new XMLAttribute("type","UInt8");
        dataarray.add(type);
        ReferenceCounting<XMLAttribute>
          name = new XMLAttribute("Name","types");
        dataarray.add(name);
        ReferenceCounting<XMLAttribute>
          nbComponent = new XMLAttribute("NumberOfComponents","1");
        dataarray.add(nbComponent);

        if (not this->__binary) {
          ReferenceCounting<XMLAttribute>
            format = new XMLAttribute("format","ascii");
          dataarray.add(format);
          xmlWriter.add(dataarray);
     
          for (size_t i=0; i<mesh.numberOfCells(); ++i) {
            xmlWriter.insert(Traits<CellType>::VTKType);
          }
          xmlWriter.insertNewLine();
          xmlWriter.closeTag();
        } else {
          ReferenceCounting<XMLAttribute>
            format = new XMLAttribute("format","appended");
          dataarray.add(format);

          ReferenceCounting<XMLAttribute>
            offset = new XMLAttribute("offset",stringify(serializer.offset()));
          dataarray.add(offset);

          Vector<unsigned char> types(mesh.numberOfCells());
          for (size_t i=0; i<mesh.numberOfCells(); ++i) {
            types[i] = Traits<CellType>::VTKType;
          }

          serializer.add(types);

          xmlWriter.add(dataarray);
          xmlWriter.closeTag();
        }
      }
    }
    xmlWriter.closeTag();
  }
  {
    XMLTag pointdata("PointData");
    xmlWriter.add(pointdata);

    for (size_t i=0; i<__scalarFunctionList.size(); ++i) {

      const ScalarFunctionBase& function = *__scalarFunctionList[i];

      if (not this->__binary) {
        XMLTag dataarray("DataArray");
        ReferenceCounting<XMLAttribute>
          type = new XMLAttribute("type","Float64");
        dataarray.add(type);
        ReferenceCounting<XMLAttribute>
          name = new XMLAttribute("Name",stringify(function));
        dataarray.add(name);
        ReferenceCounting<XMLAttribute>
          nbComponent = new XMLAttribute("NumberOfComponents","1");
        dataarray.add(nbComponent);
        ReferenceCounting<XMLAttribute>
          format = new XMLAttribute("format","ascii");
        dataarray.add(format);
    
        xmlWriter.add(dataarray);

        switch (function.type()) {
        case ScalarFunctionBase::femfunction: {
          const FEMFunctionBase& fem
            = static_cast<const FEMFunctionBase&>(function);

          if ((fem.discretizationType() == ScalarDiscretizationTypeBase::lagrangianFEM1)
              and (fem.baseMesh() == __mesh)) {
            for (size_t i=0; i<mesh.numberOfVertices(); ++i) {
              xmlWriter.insert(fem[i]);
            }
            break;
          }
        }
        default: {
          for (size_t i=0; i<mesh.numberOfVertices(); ++i) {
            const Vertex& x = mesh.vertex(i);
            xmlWriter.insert(function(x));
          }
        }
        }

        xmlWriter.insertNewLine();
        xmlWriter.closeTag();
      } else {
        XMLTag dataArray("DataArray");
        ReferenceCounting<XMLAttribute> type
          = new XMLAttribute("type","Float64");
        dataArray.add(type);
        ReferenceCounting<XMLAttribute> name
          = new XMLAttribute("Name",stringify(function));
        dataArray.add(name);
        ReferenceCounting<XMLAttribute>
          nbComponent = new XMLAttribute("NumberOfComponents","1");
        dataArray.add(nbComponent);

        ReferenceCounting<XMLAttribute>
          format = new XMLAttribute("format","appended");
        dataArray.add(format);

        ReferenceCounting<XMLAttribute>
          offset = new XMLAttribute("offset",stringify(serializer.offset()));
        dataArray.add(offset);

        xmlWriter.add(dataArray);
        xmlWriter.closeTag();

        Vector<real_t> values(mesh.numberOfVertices());

        switch (function.type()) {
        case ScalarFunctionBase::femfunction: {
          const FEMFunctionBase& fem
            = static_cast<const FEMFunctionBase&>(function);

          if ((fem.discretizationType() == ScalarDiscretizationTypeBase::lagrangianFEM1)
              and (fem.baseMesh() == __mesh)) {
            for (size_t i=0; i<mesh.numberOfVertices(); ++i) {
              values[i] = fem[i];
            }
            break;
          }
        }
        default: {
          for (size_t i=0; i<mesh.numberOfVertices(); ++i) {
            const Vertex& x = mesh.vertex(i);
            values[i] = function(x);
          }
        }
        }
        serializer.add(values);
      }
    }

    for (size_t i=0; i<__fieldList.size(); ++i) {

      const FieldOfScalarFunction& field = *__fieldList[i];

      XMLTag dataArray("DataArray");
      ReferenceCounting<XMLAttribute> type
        = new XMLAttribute("type","Float64");
      dataArray.add(type);
      ReferenceCounting<XMLAttribute> name
        = new XMLAttribute("Name",stringify(field));
      dataArray.add(name);
      ReferenceCounting<XMLAttribute>
        nbComponent = new XMLAttribute("NumberOfComponents",
                                       stringify(field.numberOfComponents()));
      dataArray.add(nbComponent);

      Vector<real_t> values(field.numberOfComponents()*__mesh->numberOfVertices());

      this->__fillCrossedComponent(field,values);
      if (not this->__binary) {
        ReferenceCounting<XMLAttribute> format
          = new XMLAttribute("format","ascii");
        dataArray.add(format);
        xmlWriter.add(dataArray);


        for (size_t i=0; i<values.size(); ++i) {
          xmlWriter.insert(values[i]);
        }

        xmlWriter.insertNewLine();
        xmlWriter.closeTag();
      } else {
        ReferenceCounting<XMLAttribute>
          format = new XMLAttribute("format","appended");
        dataArray.add(format);

        ReferenceCounting<XMLAttribute>
          offset = new XMLAttribute("offset",stringify(serializer.offset()));
        dataArray.add(offset);

        xmlWriter.add(dataArray);
        xmlWriter.closeTag();

        serializer.add(values);
      }
    }

    xmlWriter.closeTag();
  }

  if (this->__binary) {
    xmlWriter.closeTag();
    xmlWriter.closeTag();
    {
      XMLTag appended("AppendedData");

      ReferenceCounting<XMLAttribute>
        encoding = new XMLAttribute("encoding","raw");

      appended.add(encoding);
      xmlWriter.add(appended);
 
      xmlWriter.insertUnderscore();

      file << serializer;

      xmlWriter.insertNewLine();
    }
  }
}

Here is the call graph for this function:

void WriterVTK::__fillCrossedComponent	(	const FieldOfScalarFunction &	field,
		Vector< real_t > &	values
	)			const [private]

Fills crossed component

Parameters:

	field	the field that will have its component crossed
	values	values vector

Definition at line 154 of file WriterVTK.cpp.

References WriterBase::__mesh, ASSERT, FEMFunctionBase::baseMesh(), Mesh::cartesianHexahedraMesh, FEMFunctionBase::discretizationType(), ScalarFunctionBase::femfunction, FieldOfScalarFunction::function(), ScalarDiscretizationTypeBase::lagrangianFEM1, FieldOfScalarFunction::numberOfComponents(), Structured3DMeshShape::nx(), Structured3DMeshShape::ny(), Structured3DMeshShape::nz(), Structured3DMesh::shape(), Vector< T >::size(), ScalarFunctionBase::type(), FEMFunctionBase::values(), and Structured3DMesh::vertex().

Referenced by __proceed().

{
  const size_t numberOfComponents = field.numberOfComponents();
  ASSERT(values.size() == __mesh->numberOfVertices()*numberOfComponents);

  switch (__mesh->type()) {
  case Mesh::cartesianHexahedraMesh: {
    const Structured3DMesh& mesh = dynamic_cast<const Structured3DMesh&>(*__mesh);
    for (size_t l = 0; l<numberOfComponents; ++l) {
      const ScalarFunctionBase& function = *field.function(l);

      switch (function.type()) {
      case ScalarFunctionBase::femfunction: {
        const FEMFunctionBase& fem
          = static_cast<const FEMFunctionBase&>(function);

        if ((fem.discretizationType() == ScalarDiscretizationTypeBase::lagrangianFEM1)
            and (fem.baseMesh() == __mesh)) {
          size_t position = 0;
          for (size_t k=0; k<mesh.shape().nz(); ++k)
            for (size_t j=0; j<mesh.shape().ny(); ++j)
              for (size_t i=0; i<mesh.shape().nx(); ++i) {
                const size_t pointNumber = mesh.shape()(i,j,k);
                values[position*numberOfComponents+l] = fem[pointNumber];
                position++;
              }
          break;
        }
      }
      default: {
        size_t position = 0;
        for (size_t k=0; k<mesh.shape().nz(); ++k)
          for (size_t j=0; j<mesh.shape().ny(); ++j)
            for (size_t i=0; i<mesh.shape().nx(); ++i) {
              const Vertex& x = mesh.vertex(i,j,k);
              values[position*numberOfComponents+l] = function(x);
              position++;
            }
      }
      }
    }
    break;
  }
  default: {
    for (size_t i = 0; i<numberOfComponents; ++i) {
      const ScalarFunctionBase& function = *field.function(i);

      switch (function.type()) {
      case ScalarFunctionBase::femfunction: {
        const FEMFunctionBase& fem
          = static_cast<const FEMFunctionBase&>(function);
        if ((fem.baseMesh() == __mesh) and
            ((fem.discretizationType() == ScalarDiscretizationTypeBase::lagrangianFEM1))) {
          for (size_t j=0; j<fem.values().size(); ++j) {
            values[numberOfComponents*j+i] = fem[j];
          }
          break;
        } // if not continues the standard method
      }
      default: {
        for (size_t j=0; j<__mesh->numberOfVertices(); ++j) {
          const TinyVector<3,real_t>& x = __mesh->vertex(j);
          values[numberOfComponents*j+i] = function(x);
        }
      }
      }
    }
  }
  }
}

Here is the call graph for this function:

void WriterVTK::proceed

(

)

const [virtual]

Save the data to the file

Implements WriterBase.

Definition at line 896 of file WriterVTK.cpp.

References WriterBase::__mesh, Mesh::cartesianHexahedraMesh, Mesh::hexahedraMesh, ErrorHandler::normal, Mesh::octreeMesh, Mesh::spectralMesh, Mesh::surfaceMeshQuadrangles, Mesh::surfaceMeshTriangles, and Mesh::tetrahedraMesh.

{
  switch (__mesh->type()) {
  case Mesh::cartesianHexahedraMesh: {
    this->__proceed<Structured3DMesh>();
    break;
  }
  case Mesh::hexahedraMesh: {
    this->__proceed<MeshOfHexahedra>();
    break;
  }
  case Mesh::octreeMesh: {
    this->__proceed<OctreeMesh>();
    break;
  }
  case Mesh::tetrahedraMesh: {
    this->__proceed<MeshOfTetrahedra>();
    break;
  }
  case Mesh::spectralMesh: {
    this->__proceed<SpectralMesh>();
    break;
  }
  case Mesh::surfaceMeshTriangles: {
    this->__proceed<SurfaceMeshOfTriangles>();
    break;
  }
  case Mesh::surfaceMeshQuadrangles: {
    this->__proceed<SurfaceMeshOfQuadrangles>();
    break;
  }
  default: {
    throw ErrorHandler(__FILE__,__LINE__,
                       "cannot save this mesh type to VTK format",
                       ErrorHandler::normal);
  }
  }
}

void WriterBase::add

(

ConstReferenceCounting< ScalarFunctionBase >

function

)

[inherited]

Adds a function to the list of functions

Parameters:

function

given function

Definition at line 32 of file WriterBase.cpp.

References WriterBase::__scalarFunctionList.

{
  __scalarFunctionList.push_back(function);
}

void WriterBase::add

(

ConstReferenceCounting< FieldOfScalarFunction >

field

)

[inherited]

Adds a field to the list of fields

Parameters:

field

given field

Definition at line 38 of file WriterBase.cpp.

References WriterBase::__fieldList.

{
  __fieldList.push_back(field);
}

---

Member Data Documentation

const bool WriterVTK::__binary [private]

binary format

Definition at line 66 of file WriterVTK.hpp.

Referenced by __proceed().

ConstReferenceCounting<Mesh> WriterBase::__mesh [protected, inherited]

the saving mesh

Definition at line 49 of file WriterBase.hpp.

Referenced by __fillCrossedComponent(), WriterMedit::__fillCrossedComponent(), __proceed(), WriterMedit::__proceedData(), WriterMedit::__proceedMesh(), WriterRaw::__saveScalarFunction(), and proceed().

const std::string WriterBase::__filename [protected, inherited]

name of the file

Definition at line 50 of file WriterBase.hpp.

Referenced by __proceed(), WriterMedit::__proceedData(), WriterMedit::__proceedMesh(), and WriterRaw::proceed().

const FileDescriptor& WriterBase::__fileDescriptor [protected, inherited]

describes file type

Definition at line 53 of file WriterBase.hpp.

Referenced by WriterRaw::__saveScalarFunction().

const std::string WriterBase::__CR [protected, inherited]

type of carriage return for text files

Definition at line 54 of file WriterBase.hpp.

Referenced by WriterMedit::__proceedData(), WriterMedit::__proceedMesh(), WriterMedit::__saveElements(), and WriterRaw::__saveScalarFunction().

FieldList WriterBase::__fieldList [protected, inherited]

the field list

Definition at line 56 of file WriterBase.hpp.

Referenced by __proceed(), WriterMedit::__proceedData(), WriterBase::add(), WriterRaw::proceed(), and WriterMedit::proceed().

ScalarFunctionList WriterBase::__scalarFunctionList [protected, inherited]

the function list

Definition at line 59 of file WriterBase.hpp.

Referenced by __proceed(), WriterMedit::__proceedData(), WriterBase::add(), WriterRaw::proceed(), and WriterMedit::proceed().

---

The documentation for this class was generated from the following files:

• WriterVTK.hpp
• WriterVTK.cpp