VTKPolyDataWriterInterface.hpp

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 TotalEnergies
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_FILEIO_VTK_VTKPOLYDATAWRITERINTERFACE_HPP_
#define GEOS_FILEIO_VTK_VTKPOLYDATAWRITERINTERFACE_HPP_
 
#include "common/DataTypes.hpp"
#include "dataRepository/WrapperBase.hpp"
#include "dataRepository/Wrapper.hpp"
#include "fileIO/vtk/VTKPVDWriter.hpp"
#include "fileIO/vtk/VTKVTMWriter.hpp"
#include "codingUtilities/EnumStrings.hpp"
 
class vtkUnstructuredGrid;
class vtkPointData;
class vtkCellData;
 
namespace geos
{
 
class DomainPartition;
class ElementRegionBase;
class ParticleRegionBase;
class EmbeddedSurfaceNodeManager;
class ElementRegionManager;
class NodeManager;
class ParticleManager;
 
namespace vtk
{
 
enum struct VTKOutputMode
{
  BINARY,
  ASCII
};
 
enum struct VTKRegionTypes
{
  CELL,
  WELL,
  SURFACE,
  PARTICLE,
  ALL
};
 
ENUM_STRINGS( VTKOutputMode,
              "binary",
              "ascii" );
 
ENUM_STRINGS( VTKRegionTypes,
              "cell",
              "well",
              "surface",
              "particle",
              "all" );
 
class VTKPolyDataWriterInterface
{
public:
  explicit VTKPolyDataWriterInterface( string outputName );
 
  void setWriteGhostCells( bool writeGhostCells )
  {
    m_writeGhostCells = writeGhostCells;
  }
 
  void setPlotLevel( integer plotLevel )
  {
    m_plotLevel = dataRepository::toPlotLevel( plotLevel );
  }
 
  void setOutputMode( VTKOutputMode mode )
  {
    m_outputMode = mode;
  }
 
  void setOutputRegionType( VTKRegionTypes regionType )
  {
    m_outputRegionType = regionType;
  }
 
  void setOutputLocation( string outputDir, string outputName )
  {
    m_outputDir = std::move( outputDir );
    m_outputName = std::move( outputName );
    m_pvd.setFileName( joinPath( m_outputDir, m_outputName ) + ".pvd" );
  }
 
  void setOnlyPlotSpecifiedFieldNamesFlag( integer const onlyPlotSpecifiedFieldNames )
  {
    m_onlyPlotSpecifiedFieldNames = onlyPlotSpecifiedFieldNames;
  }
 
  void setFieldNames( arrayView1d< string const > const & fieldNames )
  {
    m_fieldNames.insert( fieldNames.begin(), fieldNames.end() );
  }
 
  void setLevelNames( arrayView1d< string const > const & levelNames )
  {
    m_levelNames.insert( levelNames.begin(), levelNames.end() );
  }
 
  void write( real64 time, integer cycle, DomainPartition const & domain );
 
  void clearData();
 
 
private:
 
  bool isFieldPlotEnabled( dataRepository::WrapperBase const & wrapper ) const;
 
  void writeCellElementRegions( real64 time,
                                ElementRegionManager const & elemManager,
                                NodeManager const & nodeManager,
                                string const & path ) const;
 
  void writeParticleRegions( real64 const time,
                             ParticleManager const & particleManager,
                             string const & path ) const;
 
  void writeWellElementRegions( real64 time,
                                ElementRegionManager const & elemManager,
                                NodeManager const & nodeManager,
                                string const & path ) const;
 
  void writeSurfaceElementRegions( real64 time,
                                   ElementRegionManager const & elemManager,
                                   NodeManager const & nodeManager,
                                   EmbeddedSurfaceNodeManager const & embSurfNodeManager,
                                   string const & path ) const;
 
  void writeVtmFile( integer const cycle,
                     DomainPartition const & domain,
                     VTKVTMWriter const & vtmWriter ) const;
  void writeNodeFields( NodeManager const & nodeManager,
                        arrayView1d< localIndex const > const & nodeIndices,
                        vtkPointData * pointData ) const;
 
  void writeElementFields( ElementRegionBase const & subRegion,
                           vtkCellData * cellData ) const;
 
  void writeParticleFields( ParticleRegionBase const & region,
                            vtkCellData * cellData ) const;
 
  void writeUnstructuredGrid( string const & path,
                              vtkUnstructuredGrid * ug ) const;
 
private:
 
  string m_outputDir;
 
  string m_outputName;
 
  VTKPVDWriter m_pvd;
 
  bool m_writeGhostCells;
 
  dataRepository::PlotLevel m_plotLevel;
 
  integer m_onlyPlotSpecifiedFieldNames;
 
  bool m_requireFieldRegistrationCheck;
 
  std::set< string > m_fieldNames;
 
  std::set< string > m_levelNames;
 
  integer m_previousCycle;
 
  VTKOutputMode m_outputMode;
 
  VTKRegionTypes m_outputRegionType;
};
 
} // namespace vtk
} // namespace geos
 
#endif