amirameshwriter.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*  This file is part of the library KASKADE 7                               */
/*  https://www.zib.de/research/projects/kaskade7-finite-element-toolbox     */
/*                                                                           */
/*  Copyright (C) 2002-2023 Zuse Institute Berlin                            */
/*                                                                           */
/*  KASKADE 7 is distributed under the terms of the ZIB Academic License.    */
/*    see $KASKADE/academic.txt                                              */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Code from Dune contributed by Oliver Sander.
 
 
#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 ((int) 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 "io/dune/amirameshwriter.cc"
#endif
 
#endif