vtkoutput.h

Go to the documentation of this file.

/*
 * Copyright (c) 2010-2015:  G-CSC, Goethe University Frankfurt
 * Author: Andreas Vogel
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * 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 Lesser General Public License for more details.
 */
 
#ifndef __H__UG__LIB_DISC__IO__VTKOUTPUT__
#define __H__UG__LIB_DISC__IO__VTKOUTPUT__
 
//TODO: deduplicate code in VTUOutput - reduces vulnerability to errors and linker time 
 
// extern libraries
#include <string>
#include <vector>
#include <map>
 
// other ug modules
#include "common/util/string_util.h"
#include "common/util/base64_file_writer.h"
#include "lib_disc/common/function_group.h"
#include "lib_disc/domain.h"
#include "lib_disc/spatial_disc/user_data/user_data.h"
 
namespace ug{
// todo this should avoid refactoring all the signatures of VTKOutput, remove it later
typedef Base64FileWriter VTKFileWriter;
 
template <typename T>
struct IteratorProvider
{
  template <typename TElem>
  struct traits
  {
    typedef typename T::template traits<TElem>::iterator iterator;
    typedef typename T::template traits<TElem>::const_iterator const_iterator;
  };
  struct traits {…};
 
  template <typename TElem>
  static typename traits<TElem>::const_iterator begin(const T& provider, int si)
  {
    if(si < 0) return provider.template begin<TElem>();
    else return provider.template begin<TElem>(si);
  }
  static typename traits<TElem>::const_iterator begin(const T& provider, int si) {…}
 
  template <typename TElem>
  static typename traits<TElem>::const_iterator end(const T& provider, int si)
  {
    if(si < 0) return provider.template end<TElem>();
    else return provider.template end<TElem>(si);
  }
  static typename traits<TElem>::const_iterator end(const T& provider, int si) {…}
};
struct IteratorProvider {…};
 
template <>
struct IteratorProvider<MGSubsetHandler>
{
  private:
  typedef MGSubsetHandler T;
 
  public:
  template <typename TElem>
  struct traits
  {
    typedef typename T::template traits<TElem>::iterator iterator;
    typedef typename T::template traits<TElem>::const_iterator const_iterator;
  };
  struct traits {…};
 
  template <typename TElem>
  static typename traits<TElem>::const_iterator begin(const T& provider, int si)
  {
    const int lev = provider.num_levels() - 1;
    if(si < 0) return provider.multi_grid()->template begin<TElem>(lev);
    else return provider.template begin<TElem>(si, lev);
  }
  static typename traits<TElem>::const_iterator begin(const T& provider, int si) {…}
 
  template <typename TElem>
  static typename traits<TElem>::const_iterator end(const T& provider, int si)
  {
    const int lev = provider.num_levels() - 1;
    if(si < 0) return provider.multi_grid()->template end<TElem>(lev);
    else return provider.template end<TElem>(si, lev);
  }
  static typename traits<TElem>::const_iterator end(const T& provider, int si) {…}
};
struct IteratorProvider<MGSubsetHandler> {…};
 
 
 
template <int TDim>
class VTKOutput
{
    public:
    void clear_selection() {m_vSymbFct.clear(); m_vSymbFctNodal.clear(); m_vSymbFctElem.clear();}
 
    void clear_data_selection()
    {
      m_vScalarNodalData.clear();
      m_vScalarElemData.clear();
 
      m_vVectorNodalData.clear();
      m_vVectorElemData.clear();
    }
    void clear_data_selection() {…}
 
    void select_all(bool bAll) {m_bSelectAll = bAll;}
 
 
    void select(const char* fctName, const char* name);
    void select(const std::vector<std::string>& vFct, const char* name);
 
 
    void select_nodal(const char* fctName, const char* name);
    void select_nodal(const std::vector<std::string>& vFct, const char* name);
 
 
    void select_element(const char* fctName, const char* name);
    void select_element(const std::vector<std::string>& vFct, const char* name);
 
 
    void select(SmartPtr<UserData<number, TDim> > spData, const char* name);
    void select(SmartPtr<UserData<MathVector<TDim>, TDim> > spData, const char* name);
    void select(SmartPtr<UserData<MathMatrix<TDim,TDim>, TDim> > spData, const char* name);
 
 
    void select_nodal(SmartPtr<UserData<number, TDim> > spData, const char* name);
    void select_nodal(SmartPtr<UserData<MathVector<TDim>, TDim> > spData, const char* name);
    void select_nodal(SmartPtr<UserData<MathMatrix<TDim,TDim>, TDim> > spData, const char* name);
 
 
    void select_element(SmartPtr<UserData<number, TDim> > spData, const char* name);
    void select_element(SmartPtr<UserData<MathVector<TDim>, TDim> > spData, const char* name);
    void select_element(SmartPtr<UserData<MathMatrix<TDim,TDim>, TDim> > spData, const char* name);
 
    template <typename TFunction>
    void print(const char*  filename, TFunction& u,
               int step, number time,
           bool makeConsistent);
 
    template <typename TFunction>
    void print(const char*  filename, TFunction& u,
               int step, number time)
    {
      return print(filename, u, step, time, true);
    }
    void print(const char*  filename, TFunction& u, {…}
 
    template <typename TFunction>
    void print(const char*  filename, TFunction& u,
           bool makeConsistent)
    {
      print(filename, u, -1, 0.0, makeConsistent);
    }
    void print(const char*  filename, TFunction& u, {…}
 
    template <typename TFunction>
    void print(const char*  filename, TFunction& u)
    {
      return print(filename, u, true);
    }
    void print(const char*  filename, TFunction& u) {…}
 
    void print(const char* filename, Domain<TDim>& domain);
 
    template <typename TFunction>
    void print_subset(const char* filename, TFunction& u,
                      int si, int step, number time,
              bool makeConsistent);
 
    template <typename TFunction>
    void print_subset(const char* filename, TFunction& u,
                      int si, int step = -1, number time = 0.0)
    {
      return print_subset(filename, u, si, step, time, true);
    }
    void print_subset(const char* filename, TFunction& u, {…}
 
    template <typename TFunction>
    void print_subsets(const char* filename, TFunction& u,
                      const SubsetGroup& ssGrp, int step = -1, number time = 0.0,
              bool makeConsistent = true);
 
    template <typename TFunction>
    void print_subsets(const char* filename, TFunction& u,
                      const char* ssNames, int step = -1, number time = 0.0,
              bool makeConsistent = true);
 
    template <typename TFunction>
    void print_subsets(const char*  filename, TFunction& u, const char* ssNames,
               int step, number time)
    {
      return print_subsets(filename, u, ssNames, step, time, true);
    }
    void print_subsets(const char*  filename, TFunction& u, const char* ssNames, {…}
 
    template <typename TFunction>
    void print_subsets(const char*  filename, TFunction& u, const char* ssNames,
           bool makeConsistent)
    {
      print_subsets(filename, u, ssNames, -1, 0.0, makeConsistent);
    }
    void print_subsets(const char*  filename, TFunction& u, const char* ssNames, {…}
 
    template <typename TFunction>
    void print_subsets(const char*  filename, TFunction& u, const char* ssNames)
    {
      return print_subsets(filename, u, ssNames, true);
    }
    void print_subsets(const char*  filename, TFunction& u, const char* ssNames) {…}
 
    template <typename TFunction>
    void write_time_pvd(const char* filename, TFunction& u);
 
    template <typename TFunction>
    void write_time_processwise_pvd(const char* filename, TFunction& u);
 
    template <typename TFunction>
    void write_time_pvd_subset(const char* filename, TFunction& u, int si);
protected:
    template <typename T>
    void
    count_piece_sizes(Grid& grid, const T& iterContainer, const SubsetGroup& ssGrp, const int dim,
                      int& numVert, int& numElem, int& numConn);
 
    template <typename TElem, typename T>
    void
    count_sizes(Grid& grid, const T& iterContainer, const int si,
                int& numVert, int& numElem, int& numConn);
 
    template <typename T>
    void
    write_points_cells_piece(VTKFileWriter& File,
                             Grid::VertexAttachmentAccessor<Attachment<int> >& aaVrtIndex,
                             const Grid::VertexAttachmentAccessor<Attachment<MathVector<TDim> > >& aaPos,
                             Grid& grid, const T& iterContainer, const SubsetGroup& ssGrp,
                             const int dim, const int numVert, const int numElem, const int numConn);
 
    template <typename T>
    void
    write_grid_piece(VTKFileWriter& File,
                     Grid::VertexAttachmentAccessor<Attachment<int> >& aaVrtIndex,
                     const Grid::VertexAttachmentAccessor<Attachment<MathVector<TDim> > >& aaPos,
                     Grid& grid, const T& iterContainer, SubsetGroup& ssGrp, int dim);
 
public:
    // maybe somebody wants to do this from outside
    static void write_empty_grid_piece(VTKFileWriter& File,
        bool binary = true);
 
    void set_user_defined_comment(const char* comment) {m_sComment = comment;};
 
protected:
 
    // writes an xml comment to a vtu file
    void write_comment(VTKFileWriter& File);
 
    // writes an xml comment to a pvd file
    void write_comment_printf(FILE* File);
 
    template <typename T>
    void
    write_points(VTKFileWriter& File,
                 Grid::VertexAttachmentAccessor<Attachment<int> >& aaVrtIndex,
                 const Grid::VertexAttachmentAccessor<Attachment<MathVector<TDim> > >& aaPos,
                 Grid& grid, const T& iterContainer, const SubsetGroup& ssGrp, const int dim,
                 const int numVert);
 
    template <typename TElem, typename T>
    void
    write_points_elementwise(VTKFileWriter& File,
                             Grid::VertexAttachmentAccessor<Attachment<int> >& aaVrtIndex,
                             const Grid::VertexAttachmentAccessor<Attachment<MathVector<TDim> > >& aaPos,
                             Grid& grid, const T& iterContainer, const int si, int& n);
 
    template <typename T>
    void
    write_cells(VTKFileWriter& File,
                Grid::VertexAttachmentAccessor<Attachment<int> >& aaVrtIndex,
                Grid& grid, const T& iterContainer, const SubsetGroup& ssGrp,
                const int dim, const int numElem, const int numConn);
 
 
    template <typename TElem, typename T>
    void
    write_cell_connectivity(VTKFileWriter& File,
                            Grid::VertexAttachmentAccessor<Attachment<int> >& aaVrtIndex,
                            Grid& grid, const T& iterContainer, const int si);
 
    template <typename T>
    void
    write_cell_connectivity(VTKFileWriter& File,
                            Grid::VertexAttachmentAccessor<Attachment<int> >& aaVrtIndex,
                            Grid& grid, const T& iterContainer, const SubsetGroup& ssGrp,
                            const int dim, const int numConn);
 
    template <typename TElem, typename T>
    void
    write_cell_offsets(VTKFileWriter& File, const T& iterContainer, const int si, int& n);
 
    template <typename T>
    void
    write_cell_offsets(VTKFileWriter& File, const T& iterContainer, const SubsetGroup& ssGrp,
                       const int dim, const int numElem);
 
    template <typename TElem, typename T>
    void
    write_cell_types(VTKFileWriter& File, const T& iterContainer, const int si);
 
    template <typename T>
    void
    write_cell_types(VTKFileWriter& File, const T& iterContainer, const SubsetGroup& ssGrp,
                     const int dim, const int numElem);
 
    template <typename TElem, typename T>
    void
    write_cell_subsets(VTKFileWriter& File, const T& iterContainer, const int si, MGSubsetHandler& sh);
 
    template <typename T>
    void
    write_cell_subsets(VTKFileWriter& File, const T& iterContainer, const SubsetGroup& ssGrp,
                     const int dim, const int numElem, MGSubsetHandler& sh);
 
    void
    write_cell_subset_names(VTKFileWriter& File, MGSubsetHandler& sh);
 
    template <typename TElem, typename T>
    void
    write_cell_proc_ranks(VTKFileWriter& File, const T& iterContainer, const int si, MGSubsetHandler& sh);
 
    template <typename T>
    void
    write_cell_proc_ranks(VTKFileWriter& File, const T& iterContainer, const SubsetGroup& ssGrp,
                     const int dim, const int numElem, MGSubsetHandler& sh);
 
  protected:
    template <typename TFunction>
    void
    write_grid_solution_piece(VTKFileWriter& File,
                  Grid::VertexAttachmentAccessor<Attachment<int> >& aaVrtIndex,
                  Grid& grid, TFunction& u, number time,
                  const SubsetGroup& ssGrp, const int dim);
 
  // nodal data
 
    template <typename TElem, typename TFunction>
    void write_nodal_values_elementwise(VTKFileWriter& File, TFunction& u,
                                        const std::vector<size_t>& vFct,
                                        Grid& grid, const int si);
 
    template <typename TFunction>
    void write_nodal_values(VTKFileWriter& File, TFunction& u,
                const std::vector<size_t>& vFct,
                const std::string& name,
                Grid& grid, const int si, const int dim,
                const int numVert);
 
    template <typename TFunction>
    void write_nodal_values(VTKFileWriter& File, TFunction& u,
                const std::vector<size_t>& vFct,
                const std::string& name,
                Grid& grid, const SubsetGroup& ssGrp, const int dim,
                const int numVert);
 
    template <typename TElem, typename TFunction, typename TData>
    void write_nodal_data_elementwise(VTKFileWriter& File, TFunction& u,
                                      number time,
                                      SmartPtr<UserData<TData, TDim> > spData,
                                      Grid& grid, const int si);
    
    template <typename TFunction, typename TData>
    void write_nodal_data(VTKFileWriter& File, TFunction& u, number time,
                          SmartPtr<UserData<TData, TDim> > spData,
                          const int numCmp,
                          const std::string& name,
                          Grid& grid, const SubsetGroup& ssGrp, const int dim,
                          const int numVert);
 
    template <typename TFunction>
    void write_nodal_values_piece(VTKFileWriter& File, TFunction& u, number time,
                                  Grid& grid, const SubsetGroup& ssGrp, const int dim,
                                  const int numVert);
 
  // cell data
 
    template <typename TElem, typename TFunction>
    void write_cell_values_elementwise(VTKFileWriter& File, TFunction& u,
                       const std::vector<size_t>& vFct,
                       Grid& grid, const int si);
 
    template <typename TFunction>
    void write_cell_values(VTKFileWriter& File, TFunction& u,
                const std::vector<size_t>& vFct,
                const std::string& name,
                Grid& grid, const SubsetGroup& ssGrp, const int dim,
                const int numElem);
 
    template <typename TElem, typename TFunction, typename TData>
    void write_cell_data_elementwise(VTKFileWriter& File, TFunction& u, number time,
                      SmartPtr<UserData<TData, TDim> > spData,
                      Grid& grid, const int si);
 
    template <typename TFunction, typename TData>
    void write_cell_data(VTKFileWriter& File, TFunction& u, number time,
                SmartPtr<UserData<TData, TDim> > spData,
                const int numCmp,
                const std::string& name,
                Grid& grid, const SubsetGroup& ssGrp, const int dim,
                const int numElem);
 
    template <typename TFunction>
    void write_cell_values_piece(VTKFileWriter& File, TFunction& u, number time,
                    Grid& grid, const SubsetGroup& ssGrp, const int dim,
                    const int numElem);
 
  // file names
 
    template <typename TFunction>
    void write_pvtu(TFunction& u, const std::string&  filename,
                    int si, int step, number time);
 
  public:
    static void write_subset_pvd(int numSubset, const std::string&  filename,
                                 int step = -1, number time = 0.0);
 
    static void vtu_filename(std::string& nameOut, std::string nameIn,
                             int rank, int si, int maxSi, int step);
 
    static void pvtu_filename(std::string& nameOut, std::string nameIn,
                              int si, int maxSi, int step);
 
    static void pvd_filename(std::string& nameOut, std::string nameIn);
 
    static void pvd_time_filename(std::string& nameOut, std::string nameIn,
                                  int step);
 
  public:
    VTKOutput() : m_bSelectAll(true), m_bBinary(true), m_bWriteGrid(true), m_bWriteSubsetIndices(false), m_bWriteProcRanks(false) {} //TODO: maybe true?
 
    void set_binary(bool b) {m_bBinary = b;};
 
    void set_write_grid(bool b) {m_bWriteGrid = b;};
 
    void set_write_subset_indices(bool b) {m_bWriteSubsetIndices = b;};
 
    void set_write_proc_ranks(bool b) {m_bWriteProcRanks = b;};
 
  protected:
    bool vtk_name_used(const char* name) const;
 
 
    inline void write_item_to_file(VTKFileWriter& File, float data);
    inline void write_item_to_file(VTKFileWriter& File, double data) {write_item_to_file(File, (float) data);};
    inline void write_item_to_file(VTKFileWriter& File, const ug::MathVector<1>& data);
    inline void write_item_to_file(VTKFileWriter& File, const ug::MathVector<2>& data);
    inline void write_item_to_file(VTKFileWriter& File, const ug::MathVector<3>& data);
    inline void write_item_to_file(VTKFileWriter& File, const ug::MathMatrix<1,1>& data);
    inline void write_item_to_file(VTKFileWriter& File, const ug::MathMatrix<2,2>& data);
    inline void write_item_to_file(VTKFileWriter& File, const ug::MathMatrix<3,3>& data);
  
    inline VTKFileWriter& write_asc_float(VTKFileWriter& File, float data);
 
  protected:
    bool m_bSelectAll;
    bool m_bBinary;
    std::map<std::string, std::vector<std::string> > m_vSymbFct;
    std::map<std::string, std::vector<std::string> > m_vSymbFctNodal;
    std::map<std::string, std::vector<std::string> > m_vSymbFctElem;
    typedef typename std::map<std::string,
        std::vector<std::string> >::iterator ComponentsIterator;
 
    std::map<std::string, SmartPtr<UserData<number, TDim> > > m_vScalarNodalData;
    std::map<std::string, SmartPtr<UserData<number, TDim> > > m_vScalarElemData;
    typedef typename std::map<std::string,
        SmartPtr<UserData<number, TDim> > >::iterator ScalarDataIterator;
 
    std::map<std::string, SmartPtr<UserData<MathVector<TDim>, TDim> > > m_vVectorNodalData;
    std::map<std::string, SmartPtr<UserData<MathVector<TDim>, TDim> > > m_vVectorElemData;
    typedef typename std::map<std::string,
        SmartPtr<UserData<MathVector<TDim>, TDim> > >::iterator VectorDataIterator;
 
    std::map<std::string, SmartPtr<UserData<MathMatrix<TDim,TDim>, TDim> > > m_vMatrixNodalData;
    std::map<std::string, SmartPtr<UserData<MathMatrix<TDim,TDim>, TDim> > > m_vMatrixElemData;
    typedef typename std::map<std::string,
        SmartPtr<UserData<MathMatrix<TDim,TDim>, TDim> > >::iterator MatrixDataIterator;
 
    std::map<std::string, std::vector<number> > m_mTimestep;
 
    bool m_bWriteGrid;
    std::string m_sComment;
 
    bool m_bWriteSubsetIndices;
    bool m_bWriteProcRanks;
};
class VTKOutput {…};
 
} // namespace ug
 
#include "vtkoutput_impl.h"
 
#endif /* __H__UG__LIB_DISC__IO__VTKOUTPUT__ */