vtkWriter.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2013-2016 Thomas Henn, Mathias J. Krause
 *                2016-2017 Albert Mink, Maximilian Gaedtke, Markus Morhard, Mathias J. Krause
 *                2021      Nicolas Hafen, Mathias J. Krause
 *  E-mail contact: info@openlb.net
 *  The most recent release of OpenLB can be downloaded at
 *  <http://www.openlb.net/>
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public
 *  License along with this program; if not, write to the Free
 *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA  02110-1301, USA.
 */
 
#ifndef VTK_WRITER_H
#define VTK_WRITER_H
 
namespace olb {
 
//Define vtkType enumarator
enum vtkType { VTI, VTU, VTP };
 
//VTKwriter class
template<typename T, typename FUNCTOR, vtkType VTKTYPE>
class VTKwriter {
public:
  static constexpr bool parallel = FUNCTOR::isSuper;
  static constexpr unsigned D = FUNCTOR::d;
  VTKwriter( const std::string & name, bool binary=true, bool compress=true );
  void addFunctor(FUNCTOR& f);
  void addFunctor(FUNCTOR& f, const std::string& functorName);
  //
 
 
 
 
  template<bool vtmAsMaster,typename F>
  void write(int iT, std::string nameCollection, F applyFunctors);
  void write(int iT = 0);
  void write(FUNCTOR& f, int iT = 0);
  void write(std::shared_ptr<FUNCTOR> ptr_f, int iT = 0);
  //   the master pvd file, where all data files are linked!
  void createMasterFile();
 
protected:
  void preamblePVD(const std::string& fullNamePVD);
  void dataPVD(int iT, const std::string& fullNamePVD,
                     const std::string& namePiece);
  void closePVD(const std::string& fullNamePVD);
 
  void preambleVTM(const std::string& fullNameVTM);
  void closeVTM(const std::string& fullNameVTM);
  void dataVTM(int iC, const std::string& fullNameVTM, const std::string& namePiece);
  template<bool vtmAsMaster=false>
  void writeVTM(int iT, int rankSize, std::string fileExtension, std::string nameCollection);
  void preambleVTU(const std::string& fullName, Vector<int,1> extent1);
  void closeVTU(const std::string& fullNamePiece);
  void cellDataVTU(const std::string& fullName, Vector<int,1> extent1);
 
  void preambleVTI(const std::string& fullName,
    const LatticeR<D> extent0, const LatticeR<D> extent1,
    PhysR<T,D> origin, T delta);
  void closeVTI(const std::string& fullNamePiece);
  void closePiece(const std::string& fullNamePiece);
 
 
  template<unsigned sourceDim>
  void dataArrayPoints(const std::string& fullName,
                       Vector<int,sourceDim> extent1, int iC=0 );
  template<unsigned sourceDim>
  void dataArraySingleFunctor(const std::string& fullName,
                 FUNCTOR& f,
                 Vector<int,sourceDim> extent1, int iC=0 );
private:
  mutable OstreamManager clout;
  bool _createFile;
  std::string const _name;
  std::vector<FUNCTOR*> _pointerVec;
  bool _binary;
  bool _compress;
};
 
 
//VTU: vtk writer for unstructured data
template<typename T, typename DESCRIPTOR, bool parallel=true>
using VTUwriter = VTKwriter<
  T,
  typename std::conditional_t<
    parallel,
    SuperContainerF<T,DESCRIPTOR,DynamicFieldGroupsD<T,typename DESCRIPTOR::fields_t>,T>,
    ContainerF<T,DESCRIPTOR,DynamicFieldGroupsD<T,typename DESCRIPTOR::fields_t>,T>
  >,
  VTU
>;
 
//VTI (image) version, corresponding to original SuperVTMwriterXD
template<typename T, typename DESCRIPTOR>
using VTIwriter = VTKwriter<
  T,
  SuperF3D<T,T>,
  VTI
>;
 
}  // namespace OLB
 
#endif