VTKBinaryFileWriter.h

Go to the documentation of this file.

// This file is part of the Peano project. For conditions of distribution and
// use, please see the copyright notice at www.peano-framework.org
#pragma once
 
 
#include "../../../PVDTimeSeriesWriter.h"
#include "tarch/logging/Log.h"
#include "tarch/plotter/griddata/unstructured/UnstructuredGridWriter.h"
 
 
namespace tarch {
  namespace plotter {
    namespace griddata {
      namespace unstructured {
        namespace vtk {
          class VTKBinaryFileWriter;
        }
      }
    }
  }
}
 
 
class tarch::plotter::griddata::unstructured::vtk::VTKBinaryFileWriter:
  public tarch::plotter::griddata::unstructured::UnstructuredGridWriter {
  private:
    static tarch::logging::Log _log;
 
    static const std::string HEADER;
 
    bool _writtenToFile;
 
    const int _precision;
 
    const std::string _doubleOrFloat;
 
    int _numberOfVertices;
 
    int _numberOfCells;
 
    int _numberOfCellEntries;
 
    std::stringstream _vertexDescription;
    std::stringstream _cellDescription;
    std::stringstream _cellTypeDescription;
    std::stringstream _vertexDataDescription;
    std::stringstream _cellDataDescription;
 
    std::string _fileName;
 
    void validateDataWriterIdentifier( const std::string& identifier ) const;
 
 
    std::string setDoubleOrFloatString(const int precision){
      if (precision < 7){
        return "float";
      } else {
        return "double";
      }
    }
 
  public:
    VTKBinaryFileWriter(const std::string&  fileName, const std::string&  indexFileName, tarch::plotter::PVDTimeSeriesWriter::IndexFileMode modeFile, double timeStamp, const int precision=6);
    virtual ~VTKBinaryFileWriter();
 
    virtual bool isOpen() override;
 
    virtual bool writeToFile() override;
 
    virtual void clear() override;
 
    virtual VertexWriter*      createVertexWriter() override;
    virtual CellWriter*        createCellWriter() override;
    virtual CellDataWriter*    createCellDataWriter( const std::string& identifier, int recordsPerCell ) override;
    virtual VertexDataWriter*  createVertexDataWriter( const std::string& identifier, int recordsPerVertex ) override;
 
    class VertexWriter:
      public tarch::plotter::griddata::unstructured::UnstructuredGridWriter::VertexWriter {
      private:
        friend class VTKBinaryFileWriter;
 
        int _currentVertexNumber;
 
        VTKBinaryFileWriter& _myWriter;
 
        std::stringstream _out;
 
        VertexWriter(VTKBinaryFileWriter& writer);
 
        VertexWriter(const VertexWriter& writer):
          _currentVertexNumber(writer._currentVertexNumber),
          _myWriter(writer._myWriter),
          _out() {
          assertion(false);
        }
      public:
        virtual ~VertexWriter();
 
        virtual int plotVertex(const tarch::la::Vector<2,double>& position) override;
        virtual int plotVertex(const tarch::la::Vector<3,double>& position) override;
 
        virtual void close() override;
    };
 
    class CellWriter:
      public tarch::plotter::griddata::unstructured::UnstructuredGridWriter::CellWriter {
      private:
        friend class VTKBinaryFileWriter;
 
        int _currentCellNumber;
 
        VTKBinaryFileWriter& _myWriter;
 
        int _cellListEntries;
 
        std::stringstream _cellOut;
 
        std::stringstream _cellTypeOut;
 
        CellWriter(VTKBinaryFileWriter& writer);
 
        CellWriter(const CellWriter& writer):
          _currentCellNumber(writer._currentCellNumber),
          _myWriter(writer._myWriter),
          _cellListEntries(writer._cellListEntries),
          _cellOut(),
          _cellTypeOut() {
          assertion(false);
        }
      public:
        virtual ~CellWriter();
 
        virtual int plotHexahedron(int vertexIndex[8]) override;
 
        virtual int plotQuadrangle(int vertexIndex[4]) override;
 
        virtual int plotLine(int vertexIndex[2]) override;
 
        virtual int plotTriangle(int vertexIndex[3]) override;
 
        virtual int plotPoint(int vertexIndex) override;
 
        virtual void close() override;
    };
 
    class CellDataWriter:
      public tarch::plotter::griddata::unstructured::UnstructuredGridWriter::CellDataWriter {
        private:
          friend class VTKBinaryFileWriter;
 
          const std::string _identifier;
 
          int _lastWriteCommandCellNumber;
 
          VTKBinaryFileWriter& _myWriter;
 
          std::stringstream _out;
 
          int _recordsPerCell;
 
          double _minValue;
          double _maxValue;
          CellDataWriter(const std::string& dataIdentifier, VTKBinaryFileWriter& writer, int recordsPerCell);
 
          CellDataWriter(const CellDataWriter& copy):
            _identifier("undef"),
            _lastWriteCommandCellNumber(-1),
            _myWriter(copy._myWriter),
            _out(),
            _recordsPerCell(-1),
            _minValue(0.0),
            _maxValue(0.0) {
            assertion(false);
          }
      public:
        virtual ~CellDataWriter();
 
        virtual void close() override;
 
        virtual void plotCell( int index, double value ) override;
        virtual void plotCell( int index, const tarch::la::Vector<2,double>& value ) override;
        virtual void plotCell( int index, const tarch::la::Vector<3,double>& value ) override;
        virtual void plotCell( int index, double* values, int numberOfValues ) override;
 
        double getMinValue() const;
        double getMaxValue() const;
 
        virtual void assignRemainingCellsDefaultValues() override;
    };
 
    class VertexDataWriter:
      public tarch::plotter::griddata::unstructured::UnstructuredGridWriter::VertexDataWriter {
        private:
        friend class VTKBinaryFileWriter;
 
        int _lastWriteCommandVertexNumber;
 
        VTKBinaryFileWriter& _myWriter;
 
        std::stringstream _out;
 
        int _recordsPerVertex;
 
        double _minValue;
        double _maxValue;
 
        std::string  _identifier;
 
        VertexDataWriter(const std::string& dataIdentifier, VTKBinaryFileWriter& writer, int recordsPerVertex);
 
        VertexDataWriter(const VertexDataWriter& copy):
          _lastWriteCommandVertexNumber(-1),
          _myWriter(copy._myWriter),
          _out(),
          _recordsPerVertex(-1),
          _minValue(0.0),
          _maxValue(0.0) {
          assertion(false);
        }
      public:
        virtual ~VertexDataWriter();
 
        virtual void close() override;
 
        virtual void plotVertex( int index, double value ) override;
        virtual void plotVertex( int index, const tarch::la::Vector<2,double>& value ) override;
        virtual void plotVertex( int index, const tarch::la::Vector<3,double>& value ) override;
        virtual void plotVertex( int index, double* values, int numberOfValues ) override;
 
        double getMinValue() const;
        double getMaxValue() const;
 
        virtual void assignRemainingVerticesDefaultValues() override;
    };
};