LinearForm.hpp

#pragma once
 
#include <dune/common/typeutilities.hh>
 
#include <amdis/Assembler.hpp>
#include <amdis/LinearAlgebra.hpp>
#include <amdis/Observer.hpp>
#include <amdis/common/Concepts.hpp>
#include <amdis/common/ConceptsBase.hpp>
#include <amdis/common/FlatVector.hpp>
#include <amdis/common/TypeTraits.hpp>
#include <amdis/typetree/TreePath.hpp>
 
namespace AMDiS
{
 
  template <class GB, class T = double, class Traits = BackendTraits>
  class LinearForm
      : public VectorFacade<T, Traits::template Vector<GB>::template Impl>
      , private Observer<event::adapt>
  {
    using Super = VectorFacade<T, Traits::template Vector<GB>::template Impl>;
    using Self = LinearForm;
 
  public:
    using GlobalBasis = GB;
 
    using CoefficientType = T;
 
    using ElementVector = FlatVector<CoefficientType>;
 
  public:
    explicit LinearForm(std::shared_ptr<GB> const& basis)
      : Super(*basis)
      , Observer<event::adapt>(*basis)
      , basis_(basis)
    {
      auto const localSize = basis->localView().maxSize();
      elementVector_.resize(localSize);
    }
 
    template <class GB_,
      REQUIRES(Concepts::Similar<GB_,GB>)>
    explicit LinearForm(GB_&& basis)
      : LinearForm(Dune::wrap_or_move(FWD(basis)))
    {}
 
    GlobalBasis const& basis() const { return *basis_; }
 
 
    template <class ContextTag, class Operator, class TreePath>
    void addOperator(ContextTag contextTag, Operator const& op, TreePath path);
 
    // Add an operator to be assembled on the elements of the grid
    template <class Operator, class TreePath = RootTreePath>
    void addOperator(Operator const& op, TreePath path = {})
    {
      using E = typename GlobalBasis::LocalView::Element;
      addOperator(tag::element_operator<E>{}, op, path);
    }
 
    // Add an operator to be assembled on the intersections of the grid
    template <class Operator, class TreePath = RootTreePath>
    void addIntersectionOperator(Operator const& op, TreePath path = {})
    {
      using I = typename GlobalBasis::LocalView::GridView::Intersection;
      addOperator(tag::intersection_operator<I>{}, op, path);
    }
 
 
    template <class LocalView,
      REQUIRES(Concepts::LocalView<LocalView>)>
    void assemble(LocalView const& localView);
 
    void assemble();
 
    auto& assembler() { return assembler_; }
 
    void updateImpl(event::adapt e) override
    {
      if (e.value)
        assembler_.update(basis_->gridView());
    }
 
  private:
    ElementVector elementVector_;
 
    VectorAssembler<GlobalBasis,ElementVector> assembler_;
 
    std::shared_ptr<GlobalBasis const> basis_;
  };
 
 
  // deduction guide
  template <class GB>
  LinearForm(GB&& basis)
    -> LinearForm<Underlying_t<GB>>;
 
 
  template <class T = double, class GB>
  auto makeLinearForm(GB&& basis)
  {
    using LF = LinearForm<Underlying_t<GB>, T>;
    return LF{FWD(basis)};
  }
 
} // end namespace AMDiS
 
#include <amdis/LinearForm.inc.hpp>