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>