DOFVector.hpp

#pragma once

#include <memory>
#include <utility>

#include <dune/common/shared_ptr.hh>

#include <amdis/DataTransfer.hpp>
#include <amdis/LinearAlgebra.hpp>
#include <amdis/Observer.hpp>
#include <amdis/common/Concepts.hpp>
#include <amdis/common/TypeTraits.hpp>
#include <amdis/gridfunctions/GridFunction.hpp>
#include <amdis/typetree/TreePath.hpp>

namespace Dune
{
  namespace Functions
  {
    template <class PB>
    class DefaultGlobalBasis;
  }
}

namespace AMDiS
{
  // Forward declarations
  template <class PB>
  class ParallelGlobalBasis;

  namespace event
  {
    struct preAdapt;
    struct postAdapt;
    template <class B> struct basisUpdate;
  }

  /// \brief The basic container that stores a base vector and a corresponding basis
  /**
   * \tparam GB  Basis of the vector
   * \tparam T   Type of the coefficients
   **/
  template <class GB, class T = double>
  class DOFVector
      : public VectorBase<GB, VectorBackend<BackendTraits<GB,T>>>
      , public Observer<GB, event::preAdapt, event::basisUpdate<GB>, event::postAdapt>
  {
    using Self = DOFVector;
    using Super = VectorBase<GB, VectorBackend<BackendTraits<GB,T>>>;
    using Obs = Observer<GB, event::preAdapt, event::basisUpdate<GB>, event::postAdapt>;

  public:
    using Backend = VectorBackend<BackendTraits<GB,T>>;

    using GlobalBasis = GB;

    /// The index/size - type
    using size_type  = typename GlobalBasis::size_type;

    /// The type of the elements of the DOFVector
    using value_type = typename Backend::value_type;

    /// Wrapper for the implementation of the transfer of data during grid adaption
    using DataTransfer = DataTransferWrapper<Self>;

  public:
    /// Constructor. Stores the shared_ptr of the basis and creates a new DataTransfer.
    DOFVector(std::shared_ptr<GB> basis,
              DataTransferOperation op = DataTransferOperation::INTERPOLATE)
      : Super(basis)
      , Obs(basis)
      , dataTransfer_(op, basis)
      , basis_(basis)
    {}

    /// Constructor creating a new basis from a Dune::Functions::DefaultGlobalBasis.
    // TODO(FM): Replace explicit type with concept check
    DOFVector(Dune::Functions::DefaultGlobalBasis<typename GB::PreBasis>&& basis,
              DataTransferOperation op = DataTransferOperation::INTERPOLATE)
      : DOFVector(std::make_shared<GB>(std::move(basis)), op)
    {}

    template <class GB_,
      REQUIRES(Concepts::Similar<GB_,GB>)>
    DOFVector(GB_&& basis, DataTransferOperation op = DataTransferOperation::INTERPOLATE)
      : DOFVector(Dune::wrap_or_move(FWD(basis)), op)
    {}


    template <class TreePath = RootTreePath>
    auto child(TreePath const& path = {})
    {
      auto&& tp = makeTreePath(path);
      return makeDOFVectorView(*this, tp);
    }

    template <class TreePath = RootTreePath>
    auto child(TreePath const& path = {}) const
    {
      auto&& tp = makeTreePath(path);
      return makeDiscreteFunction(*this, tp);
    }


    /// Interpolation of GridFunction to DOFVector, assuming that there is no
    /// reference to this DOFVector in the expression.
    /// See \ref DOFVectorView::interpolate_noalias
    template <class Expr, class Tag = tag::average>
    void interpolate_noalias(Expr&& expr, Tag strategy)
    {
      child().interpolate_noalias(FWD(expr), strategy);
    }

    /// Interpolation of GridFunction to DOFVector.
    /// See \ref DOFVectorView::interpolate
    template <class Expr, class Tag = tag::average>
    void interpolate(Expr&& expr, Tag strategy)
    {
      child().interpolate(FWD(expr), strategy);
    }

    /// Interpolation of GridFunction to DOFVector.
    /// See \ref DOFVectorView::interpolate
    template <class Expr>
    DOFVector& operator<<(Expr&& expr)
    {
      child().interpolate(FWD(expr));
      return *this;
    }


    /// Write DOFVector to file
    void backup(std::string const& filename);

    /// Read backup data from file
    void restore(std::string const& filename);


    /// Return the associated DataTransfer object
    DataTransfer const& dataTransfer() const
    {
      return dataTransfer_;
    }

    /// Return the associated DataTransfer object
    DataTransfer& dataTransfer()
    {
      return dataTransfer_;
    }

    /// Assign the DataTransfer object
    void setDataTransfer(DataTransfer const& dataTransfer)
    {
      dataTransfer_ = dataTransfer;
    }

    void setDataTransfer(DataTransfer&& dataTransfer)
    {
      dataTransfer_ = std::move(dataTransfer);
    }

    /// Create a new DataTransfer object based on the operation type
    void setDataTransfer(DataTransferOperation op)
    {
      setDataTransfer(newDataTransfer(op, basis_));
    }

    /// Override of Observer update(event::preAdapt) method. Redirects to preAdapt method of the
    /// \ref DataTransfer object.
    void update(event::preAdapt const& e) override
    {
      dataTransfer_.preAdapt(*this, e.mightCoarsen);
    }

    /// Override of Observer update(event::adapt) method. Redirects to adapt method of the
    /// \ref DataTransfer object.
    void update(event::basisUpdate<GB> const&) override
    {
      this->resize();
      dataTransfer_.adapt(*this);
    }

    /// Override of Observer update(event::postAdapt) method. Redirects to postAdapt method of the
    /// \ref DataTransfer object.
    void update(event::postAdapt const&) override
    {
      dataTransfer_.postAdapt(*this);
    }

  private:
    /// Data interpolation when the grid changes, set by default
    /// to \ref DataTransferOperation::INTERPOLATE.
    DataTransfer dataTransfer_;

    std::shared_ptr<GB> basis_;
  };

#if DUNE_HAVE_CXX_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
  template <class GB>
  DOFVector(GB&& basis, DataTransferOperation op = DataTransferOperation::INTERPOLATE)
    -> DOFVector<ParallelGlobalBasis<typename Underlying_t<GB>::PreBasis>>;
#endif

  /// \brief Create a DOFVector from a basis.
  /**
   * This generator function accepts the basis as reference, temporary, or
   * shared_ptr. Internally the reference is wrapped into a non-destroying
   * shared_ptr and the temporary is moved into a new shared_ptr.
   *
   * The DataTransferOperation controls what is done during grid changes with the
   * DOFVector. The default is interpolation of the data to the new grid. See
   * \ref DataTransferOperation for more options.
   **/
  template <class ValueType = double, class GB>
  DOFVector<ParallelGlobalBasis<typename Underlying_t<GB>::PreBasis>, ValueType>
  makeDOFVector(GB&& basis, DataTransferOperation op = DataTransferOperation::INTERPOLATE)
  {
    return {FWD(basis), op};
  }

} // end namespace AMDiS

#include <amdis/DOFVector.inc.hpp>