amirameshwriter.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_AMIRAMESH_WRITER_HH
#define DUNE_AMIRAMESH_WRITER_HH
 
#include <string>
#include <array>
 
#if HAVE_AMIRAMESH
#include <amiramesh/AmiraMesh.h>
#endif
 
namespace Dune {
 
  template<class GridView>
  class AmiraMeshWriter {
 
    enum {dim = GridView::dimension};
 
  public:
 
    void addGrid(const GridView& gridView, bool splitAll=false);
 
    template <class GridType2>
    void addLevelGrid(const GridType2& grid, int level, bool splitAll=false);
 
    template <class GridType2>
    void addLeafGrid(const GridType2& grid, bool splitAll=false);
 
    template <class DataContainer>
    void addCellData(const DataContainer& data, const GridView& gridView, bool GridSplitUp=false);
 
    template <class DataContainer>
    void addVertexData(const DataContainer& data, const GridView& gridView, bool GridSplitUp=false);
 
    void write(const std::string& filename, bool ascii=false) const;
 
    template <class DataContainer>
    void addUniformData(const GridView& gridView,
                        const std::array<unsigned int, dim>& n,
                        const DataContainer& data);
 
    static void writeSurfaceGrid(const GridView& gridView,
                                 const std::string& filename);
 
  protected:
 
#if HAVE_AMIRAMESH  // better: use a pointer here and forward-declare AmiraMesh
    AmiraMesh amiramesh_;
#endif
  };
 
  template<class GridType>
  class LevelAmiraMeshWriter
    : public AmiraMeshWriter<typename GridType::LevelGridView>
  {
 
  public:
 
    LevelAmiraMeshWriter() {}
 
    LevelAmiraMeshWriter(const GridType& grid, int level) {
      this->addGrid(grid.levelGridView(level));
    }
 
    static void writeGrid(const GridType& grid,
                          const std::string& filename,
                          int level) {
      LevelAmiraMeshWriter amiramesh(grid, level);
      amiramesh.write(filename);
    }
 
    template <class VectorType>
    static void writeBlockVector(const GridType& grid,
                                 const VectorType& f,
                                 const std::string& filename,
                                 int level,
                                 bool GridSplitUp=false) {
      LevelAmiraMeshWriter amiramesh;
      if (f.size()==grid.size(level,GridType::dimension))
        amiramesh.addVertexData(f, grid.levelGridView(level),GridSplitUp);
      else
        amiramesh.addCellData(f, grid.levelGridView(level),GridSplitUp);
      amiramesh.write(filename);
    }
 
  };
 
  template<class GridType>
  class LeafAmiraMeshWriter
    : public AmiraMeshWriter<typename GridType::LeafGridView>
  {
 
  public:
 
    LeafAmiraMeshWriter() {}
 
    LeafAmiraMeshWriter(const GridType& grid) {
      this->addLeafGrid(grid);
    }
 
    static void writeGrid(const GridType& grid,
                          const std::string& filename) {
      LeafAmiraMeshWriter amiramesh(grid);
      amiramesh.write(filename);
    }
 
    template <class VectorType>
    static void writeBlockVector(const GridType& grid,
                                 const VectorType& f,
                                 const std::string& filename,
                                 bool GridSplitUp = false) {
      LeafAmiraMeshWriter amiramesh;
      if (f.size()==grid.size(GridType::dimension))
        amiramesh.addVertexData(f, grid.leafGridView(),GridSplitUp);
      else
        amiramesh.addCellData(f, grid.leafGridView(),GridSplitUp);
 
      amiramesh.write(filename);
    }
 
  };
 
}
 
// implementation
#if HAVE_AMIRAMESH
#include "amiramesh/amirameshwriter.cc"
#endif
 
#endif