DOFVector.hpp

#pragma once
 
#include <memory>
#include <utility>
 
#include <dune/common/concept.hh>
#include <dune/common/shared_ptr.hh>
#include <dune/functions/functionspacebases/concepts.hh>
 
#include <amdis/DataTransfer.hpp>
#include <amdis/LinearAlgebra.hpp>
#include <amdis/Observer.hpp>
#include <amdis/common/Concepts.hpp>
#include <amdis/common/DerivativeTraits.hpp>
#include <amdis/common/TypeTraits.hpp>
#include <amdis/datatransfers/InterpolationDataTransfer.hpp>
#include <amdis/functions/GlobalBasis.hpp>
#include <amdis/typetree/TreePath.hpp>
 
namespace AMDiS
{
  // forward declaration
  template <class, class, class, class>
  class DiscreteFunction;
 
  // forward declaration
  template <class, class>
  class DerivativeGridFunction;
 
 
 
  template <class GB, class T = double, class Traits = BackendTraits>
  class DOFVector
      : public VectorFacade<T, Traits::template Vector<GB>::template Impl>
      , private Observer<event::preAdapt>
      , private Observer<event::adapt>
      , private Observer<event::postAdapt>
  {
    using Self = DOFVector;
 
    template <class, class, class, class>
    friend class DiscreteFunction;
 
  public:
    using GlobalBasis = GB;
 
    using Coefficients = VectorFacade<T, Traits::template Vector<GB>::template Impl>;
 
    using size_type  = typename GlobalBasis::size_type;
 
    using value_type = T;
 
    template <class Self>
    static auto& coefficients(Self& self)
    {
      if constexpr(std::is_const_v<Self>)
        return static_cast<Coefficients const&>(self);
      else
        return static_cast<Coefficients&>(self);
    }
 
  public:
    template <class DataTransferTag = tag::interpolation_datatransfer>
    DOFVector(std::shared_ptr<GB> const& basis, DataTransferTag = {})
      : Coefficients(*basis)
      , Observer<event::preAdapt>(basis->gridView().grid())
      , Observer<event::adapt>(*basis)
      , Observer<event::postAdapt>(basis->gridView().grid())
      , dataTransfer_(DataTransferFactory<DataTransferTag>::create(*basis, coefficients(*this)))
      , basis_(basis)
    {
      resizeZero();
    }
 
    template <class GB_, class DataTransferTag = tag::interpolation_datatransfer,
      REQUIRES(Concepts::Similar<GB_,GB>)>
    DOFVector(GB_&& basis, DataTransferTag tag = {})
      : DOFVector(Dune::wrap_or_move(FWD(basis)), tag)
    {}
 
    template <class GV, class PBF, class DataTransferTag = tag::interpolation_datatransfer,
      REQUIRES(Concepts::PreBasisFactory<PBF, GV>)>
    DOFVector(GV const& gridView, PBF const& preBasisFactory, DataTransferTag tag = {})
      : DOFVector(std::make_shared<GB>(gridView, preBasisFactory), tag)
    {}
 
    GlobalBasis const& basis() const
    {
      return *basis_;
    }
 
    Coefficients const& coefficients() const
    {
      return coefficients(*this);
    }
 
    Coefficients& coefficients()
    {
      return coefficients(*this);
    }
 
    void backup(std::string const& filename);
 
    void restore(std::string const& filename);
 
    void resize()
    {
      Coefficients::resize(*basis_);
    }
 
    using Coefficients::resize;
 
    void resizeZero()
    {
      Coefficients::resizeZero(*basis_);
    }
 
    using Coefficients::resizeZero;
 
    auto const& dataTransfer() const
    {
      return dataTransfer_;
    }
 
    auto& dataTransfer()
    {
      return dataTransfer_;
    }
 
    void setDataTransfer(DataTransfer<GB,Coefficients> dataTransfer)
    {
      dataTransfer_ = std::move(dataTransfer);
    }
 
    template <class DataTransferTag>
    void setDataTransfer(DataTransferTag tag)
    {
      setDataTransfer(DataTransferFactory<DataTransferTag>::create(basis(), coefficients()));
    }
 
 
  public: // functions to transform the DOFVector into a grid-function
 
    template <class Range = void, class... Indices>
    friend auto valueOf(DOFVector& dofVec, Indices... ii)
    {
      using TP = TYPEOF(makeTreePath(ii...));
      using DF = DiscreteFunction<Coefficients,GlobalBasis,TP,Range>;
      return DF{dofVec.coefficients(), dofVec.basis_, makeTreePath(ii...)};
    }
 
    template <class Range = void, class... Indices>
    friend auto valueOf(DOFVector const& dofVec, Indices... ii)
    {
      using TP = TYPEOF(makeTreePath(ii...));
      using DF = DiscreteFunction<Coefficients const,GlobalBasis,TP,Range>;
      return DF{dofVec.coefficients(), dofVec.basis_, makeTreePath(ii...)};
    }
 
    template <class Type>
    auto makeDerivative(Type type) const
    {
      using TP = TYPEOF(makeTreePath());
      using DF = DiscreteFunction<Coefficients const,GlobalBasis,TP,void>;
      return DerivativeGridFunction<DF,Type>{
        DF{coefficients(), basis_, makeTreePath()}, type};
    }
 
    template <class Type>
    friend auto derivativeOf(DOFVector const& dofVec, Type type)
    {
      return dofVec.makeDerivative(type);
    }
 
    friend auto gradientOf(DOFVector const& dofVec)
    {
      return dofVec.makeDerivative(tag::gradient{});
    }
 
    friend auto divergenceOf(DOFVector const& dofVec)
    {
      return dofVec.makeDerivative(tag::divergence{});
    }
 
    friend auto partialDerivativeOf(DOFVector const& dofVec, std::size_t comp)
    {
      return dofVec.makeDerivative(tag::partial{comp});
    }
 
  protected:
 
    void updateImpl(event::preAdapt e) override
    {
      dataTransfer_.preAdapt(*basis_, coefficients(), e.value);
    }
 
    void updateImpl(event::adapt e) override
    {
      assert(e.value);
      resize();
      dataTransfer_.adapt(*basis_, coefficients());
    }
 
    void updateImpl(event::postAdapt) override
    {
      dataTransfer_.postAdapt(coefficients());
    }
 
  private:
    DataTransfer<GB,Coefficients> dataTransfer_;
 
    std::shared_ptr<GlobalBasis const> basis_;
  };
 
 
  // deduction guides
  template <class GB>
  DOFVector(GB&& basis)
    -> DOFVector<Underlying_t<GB>>;
 
  template <class GB, class DataTransferTag,
    REQUIRES(std::is_base_of_v<tag::datatransfer, DataTransferTag>)>
  DOFVector(GB&& basis, DataTransferTag)
    -> DOFVector<Underlying_t<GB>>;
 
  template <class GV, class PBF,
    REQUIRES(Concepts::PreBasisFactory<PBF, GV>)>
  DOFVector(GV const& gridView, PBF const& pbf)
    -> DOFVector<decltype(GlobalBasis{gridView,pbf})>;
 
  template <class GV, class PBF, class DataTransferTag,
    REQUIRES(Concepts::PreBasisFactory<PBF, GV>),
    REQUIRES(std::is_base_of_v<tag::datatransfer, DataTransferTag>)>
  DOFVector(GV const& gridView, PBF const& pbf, DataTransferTag)
    -> DOFVector<decltype(GlobalBasis{gridView,pbf})>;
 
 
 
  template <class ValueType = double, class GB,
            class DataTransferTag = tag::interpolation_datatransfer>
  DOFVector<Underlying_t<GB>, ValueType>
  makeDOFVector(GB&& basis, DataTransferTag tag = {})
  {
    return {FWD(basis), tag};
  }
 
} // end namespace AMDiS
 
#include <amdis/DOFVector.inc.hpp>