DirichletBC.hpp

#pragma once

#include <functional>
#include <utility>
#include <vector>

#include <dune/common/concept.hh>
#include <dune/functions/functionspacebases/concepts.hh>
#include <dune/functions/functionspacebases/subspacebasis.hh>

#include <amdis/Boundary.hpp>
#include <amdis/BoundaryCondition.hpp>
#include <amdis/BoundarySubset.hpp>
#include <amdis/common/Concepts.hpp>
#include <amdis/common/TypeTraits.hpp>
#include <amdis/typetree/RangeType.hpp>
#include <amdis/typetree/TreePath.hpp>

namespace AMDiS
{

  template <class SubBasis, class ValueGridFct>
  class DirichletBC
  {
    // We assume CB's GridView to be the same as RB's
    using GridView = typename SubBasis::GridView;
    using Intersection = typename GridView::Intersection;

    using Domain = typename GridView::template Codim<0>::Geometry::GlobalCoordinate;
    using Range = TYPEOF(std::declval<ValueGridFct>()(std::declval<Domain>()));

  public:
    template <class Values,
      REQUIRES(Concepts::Functor<Values, Range(Domain)>)>
    DirichletBC(SubBasis basis, BoundarySubset<Intersection> boundarySubset, Values&& values)
      : basis_(std::move(basis))
      , boundarySubset_(std::move(boundarySubset))
      , values_(FWD(values))
    {}

    template <class Basis, class TP, class Values,
      REQUIRES(Concepts::GlobalBasis<Basis>)>
    DirichletBC(Basis const& basis, TP const& treePath,
                BoundarySubset<Intersection> boundarySubset, Values&& values)
      : DirichletBC(Dune::Functions::subspaceBasis(basis, treePath),
                    std::move(boundarySubset), FWD(values))
    {}

    template <class Basis, class Values,
      REQUIRES(Concepts::GlobalBasis<Basis>)>
    DirichletBC(Basis const& basis, BoundarySubset<Intersection> boundarySubset, Values&& values)
      : DirichletBC(Dune::Functions::subspaceBasis(basis, makeTreePath()),
                    std::move(boundarySubset), FWD(values))
    {}



    void init();


    template <class Mat, class Sol, class Rhs>
    void apply(Mat& matrix, Sol& solution, Rhs& rhs);

  private:
    SubBasis basis_;
    BoundarySubset<Intersection> boundarySubset_;
    ValueGridFct values_;

    std::vector<bool> dirichletNodes_;
  };

  // deduction guides

  // Make a DirichletBC from subspacebases
  template <class B, class TP, class Values>
  DirichletBC(Dune::Functions::SubspaceBasis<B, TP>,
              BoundarySubset<typename B::GridView::Intersection>, Values const&)
    -> DirichletBC<Dune::Functions::SubspaceBasis<B,TP>, Underlying_t<Values>>;

  // Make a DirichletBC from a basis with treepath arguments
  template <class B, class TP, class Values,
    REQUIRES(Concepts::GlobalBasis<B>)>
  DirichletBC(B const&, TP const&, BoundarySubset<typename B::GridView::Intersection>, Values const&)
    -> DirichletBC<Dune::Functions::SubspaceBasis<B, TP>, Underlying_t<Values>>;

  // Make a DirichletBC from a global basis
  template <class B, class Values,
    REQUIRES(Concepts::GlobalBasis<B>)>
  DirichletBC(B const&, BoundarySubset<typename B::GridView::Intersection>, Values const&)
    -> DirichletBC<Dune::Functions::SubspaceBasis<B,TYPEOF(makeTreePath())>, Underlying_t<Values>>;

} // end namespace AMDiS

#include "DirichletBC.inc.hpp"