vtkexport.hh

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=8 sw=2 sts=2:
 
#ifndef DUNE_PDELAB_COMMON_VTKEXPORT_HH
#define DUNE_PDELAB_COMMON_VTKEXPORT_HH
 
#include<cstddef>
#include<string>
#include<vector>
#include<memory>
 
#include<dune/common/shared_ptr.hh>
 
#include<dune/grid/io/file/vtk/vtkwriter.hh>
 
#include<dune/pdelab/common/range.hh>
 
namespace Dune {
  namespace PDELab {
 
    template<typename T> // T is a grid function
    class VTKGridFunctionAdapter
      : public Dune::VTKFunction<typename T::Traits::GridViewType>
    {
      typedef typename T::Traits::GridViewType::Grid::ctype DF;
      enum {n=T::Traits::GridViewType::dimension};
      typedef typename T::Traits::GridViewType::Grid::template Codim<0>::Entity Entity;
 
    public:
 
      VTKGridFunctionAdapter(const T& t_, std::string s_,
                             const std::vector<std::size_t> &remap_ =
                               rangeVector(std::size_t(T::Traits::dimRange)))
        : t(stackobject_to_shared_ptr(t_)), s(s_), remap(remap_)
      {}
 
 
      VTKGridFunctionAdapter(const std::shared_ptr<const T>& t_, std::string s_,
                             const std::vector<std::size_t> &remap_ =
                               rangeVector(std::size_t(T::Traits::dimRange)))
        : t(t_), s(s_), remap(remap_)
      { }
 
      virtual int ncomps () const override
      {
        return remap.size();;
      }
 
      virtual double evaluate (int comp, const Entity& e, const Dune::FieldVector<DF,n>& xi) const override
      {
        typename T::Traits::DomainType x;
        typename T::Traits::RangeType y;
 
        for (int i=0; i<n; i++)
          x[i] = xi[i];
        t->evaluate(e,x,y);
        return y[remap[comp]];
      }
 
      virtual std::string name () const override
      {
        return s;
      }
 
    private:
      std::shared_ptr<const T> t;
      std::string s;
      std::vector<std::size_t> remap;
    };
 
 
    template<class GF>
    std::shared_ptr<VTKGridFunctionAdapter<GF> > makeVTKGridFunctionAdapter
    ( const std::shared_ptr<GF> &gf, const std::string &name,
      const std::vector<std::size_t> &remap =
        rangeVector(std::size_t(GF::Traits::dimRange)))
    { return std::make_shared<VTKGridFunctionAdapter<GF> >(gf, name, remap); }
 
 
    template<class GF>
    std::shared_ptr<VTKGridFunctionAdapter<GF> > makeVTKGridFunctionAdapter
    ( const GF &gf, const std::string &name,
      const std::vector<std::size_t> &remap =
        rangeVector(std::size_t(GF::Traits::dimRange)))
    { return std::make_shared<VTKGridFunctionAdapter<GF> >(stackobject_to_shared_ptr(gf), name, remap); }
 
 
    template<class GF>
    std::shared_ptr<VTKGridFunctionAdapter<GF> > makeVTKGridFunctionAdapter
    ( const std::shared_ptr<const GF> &gf, const std::string &name,
      const std::vector<std::size_t> &remap =
        rangeVector(std::size_t(GF::Traits::dimRange)))
    { return std::make_shared<VTKGridFunctionAdapter<GF> >(gf, name, remap); }
 
    template<typename G, typename FEM>
    class VTKFiniteElementMapAdapter
      : public Dune::VTKFunction<G>
    {
      typedef typename G::ctype DF;
      enum {n=G::dimension};
      typedef typename G::template Codim<0>::Entity Entity;
 
    public:
      VTKFiniteElementMapAdapter (const FEM& fem_, std::string s_)
        : fem(fem_), s(s_)
      {}
 
      virtual int ncomps () const override
      {
        return 1;
      }
 
      virtual double evaluate (int comp, const Entity& e, const Dune::FieldVector<DF,n>& xi) const override
      {
        return fem.getOrder(e);
      }
 
      virtual std::string name () const override
      {
        return s;
      }
 
    private:
      const FEM& fem;
      std::string s;
    };
 
  }
}
 
#endif // DUNE_PDELAB_COMMON_VTKEXPORT_HH