VTUTextFileWriter.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 "tarch/logging/Log.h"
#include "tarch/plotter/griddata/unstructured/UnstructuredGridWriter.h"
#include <vector>
#include <string>
#include "../../../PVDTimeSeriesWriter.h"
 
 
namespace tarch {
  namespace plotter {
    namespace griddata {
      namespace unstructured {
        namespace vtk {
          class VTUTextFileWriter;
        }
      }
    }
  }
}
 
 
class tarch::plotter::griddata::unstructured::vtk::VTUTextFileWriter:
  public tarch::plotter::griddata::unstructured::UnstructuredGridWriter {
  private:
    static tarch::logging::Log _log;
 
    static const std::string HEADER;
 
    const std::string _dataType;
 
    bool _writtenToFile;
 
    int _numberOfVertices;
 
    int _numberOfCells;
 
    std::string _vertexDescription;
    std::string _cellDescription;
    std::string _vertexDataDescription;
    std::string _cellDataDescription;
    std::string _parallelVertexDataDescription;
    std::string _parallelCellDataDescription;
 
    std::string _fileName;
 
    void validateDataWriterIdentifier( const std::string& identifier ) const;
 
  public:
    VTUTextFileWriter(const std::string&  fileName, const std::string&  indexFileName, tarch::plotter::PVDTimeSeriesWriter::IndexFileMode modeFile, double timeStamp, const int precision=6);
    virtual ~VTUTextFileWriter();
 
    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;
 
    void writeMetaDataFileForParallelSnapshot(
      const std::string& metaDataFilename,
      const std::vector< std::string >& files
    );
 
    class VertexWriter:
      public tarch::plotter::griddata::unstructured::UnstructuredGridWriter::VertexWriter {
      private:
        friend class VTUTextFileWriter;
 
 
        const std::string _dataType;
 
        int _currentVertexNumber;
 
        VTUTextFileWriter& _myWriter;
 
        std::ostringstream _out;
 
        VertexWriter(VTUTextFileWriter& writer, std::string datatype);
 
        VertexWriter(const VertexWriter& writer):
          _dataType(writer._dataType),
          _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 VTUTextFileWriter;
 
        const std::string _dataType;
 
        int _currentCellNumber;
        int _currentCellOffset;
 
        VTUTextFileWriter& _myWriter;
 
        std::ostringstream _connectivityOut;
 
        std::ostringstream _offsetsOut;
 
        std::ostringstream _typesOut;
 
        CellWriter(VTUTextFileWriter& writer, std::string datatype);
 
        CellWriter(const CellWriter& writer):
          _dataType(writer._dataType),
          _currentCellNumber(writer._currentCellNumber),
          _currentCellOffset(writer._currentCellOffset),
          _myWriter(writer._myWriter),
          _connectivityOut(),
          _offsetsOut(),
          _typesOut() {
          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 VTUTextFileWriter;
 
          const std::string _dataType;
 
          const std::string _identifier;
 
          int _lastWriteCommandCellNumber;
 
          VTUTextFileWriter& _myWriter;
 
          std::ostringstream _out;
 
          int _recordsPerCell;
 
          double _minValue;
          double _maxValue;
          CellDataWriter(const std::string& dataIdentifier, VTUTextFileWriter& writer, int recordsPerCell, std::string dataType);
 
          CellDataWriter(const CellDataWriter& copy):
            _dataType(copy._dataType),
            _myWriter(copy._myWriter) {
            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 VTUTextFileWriter;
 
        const std::string _dataType;
 
        int _lastWriteCommandVertexNumber;
 
        VTUTextFileWriter& _myWriter;
 
        std::ostringstream _out;
 
        int _recordsPerVertex;
 
        double _minValue;
        double _maxValue;
 
        std::string  _identifier;
 
        VertexDataWriter(const std::string& dataIdentifier, VTUTextFileWriter& writer, int recordsPerVertex, std::string dataType);
 
        VertexDataWriter(const VertexDataWriter& copy):
          _dataType(copy._dataType),
          _myWriter(copy._myWriter) {
          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;
    };
};