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 Mat, class Sol, class Rhs, class RowSubBasis, class ColSubBasis,
            class ValueGridFct>
  class DirichletBC
      : public BoundaryCondition<Mat, Sol, Rhs>
  {
    using Super = BoundaryCondition<Mat, Sol, Rhs>;

    // We assume CB's GridView to be the same as RB's
    using GridView = typename RowSubBasis::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(RowSubBasis rowBasis, ColSubBasis colBasis,
                BoundarySubset<Intersection> boundarySubset, Values&& values)
      : rowBasis_(std::move(rowBasis))
      , colBasis_(std::move(colBasis))
      , boundarySubset_(std::move(boundarySubset))
      , values_(FWD(values))
    {}


    void init() override;


    void apply(Mat& matrix, Sol& solution, Rhs& rhs) override;

  private:
    RowSubBasis rowBasis_;
    ColSubBasis colBasis_;
    BoundarySubset<Intersection> boundarySubset_;
    ValueGridFct values_;

    std::vector<bool> dirichletNodes_;
  };


  template <class Mat, class Sol, class Rhs, class RB, class RTP, class CB, class CTP, class Values>
  auto makeDirichletBC(Dune::Functions::SubspaceBasis<RB, RTP> rowBasis,
                       Dune::Functions::SubspaceBasis<CB, CTP> colBasis,
                       BoundarySubset<typename RB::GridView::Intersection> boundarySubset,
                       Values&& values)
  {
    using RowSubBasis = Dune::Functions::SubspaceBasis<RB, RTP>;
    using ColSubBasis = Dune::Functions::SubspaceBasis<CB, CTP>;
    using BcType = DirichletBC<Mat, Sol, Rhs, RowSubBasis, ColSubBasis, TYPEOF(values)>;
    return BcType(std::move(rowBasis), std::move(colBasis), std::move(boundarySubset), FWD(values));
  }

  template <class Mat, class Sol, class Rhs, class RB, class RTP, class CB, class CTP, class Values,
    REQUIRES(Concepts::GlobalBasis<RB>),
    REQUIRES(Concepts::GlobalBasis<CB>)>
  auto makeDirichletBC(RB const& rowBasis, RTP const& rowTreePath,
                       CB const& colBasis, CTP const& colTreePath,
                       BoundarySubset<typename RB::GridView::Intersection> boundarySubset,
                       Values&& values)
  {
    return makeDirichletBC<Mat,Sol,Rhs>(
        Dune::Functions::subspaceBasis(rowBasis, rowTreePath),
        Dune::Functions::subspaceBasis(colBasis, colTreePath),
        std::move(boundarySubset), FWD(values));
  }

  template <class Mat, class Sol, class Rhs, class RB, class CB, class Values,
    REQUIRES(Concepts::GlobalBasis<RB>),
    REQUIRES(Concepts::GlobalBasis<CB>)>
  auto makeDirichletBC(RB const& rowBasis, CB const& colBasis,
                       BoundarySubset<typename RB::GridView::Intersection> boundarySubset,
                       Values&& values)
  {
    return makeDirichletBC<Mat, Sol, Rhs>(
        rowBasis, makeTreePath(), colBasis, makeTreePath(),
        std::move(boundarySubset), FWD(values));
  }

} // end namespace AMDiS

#include "DirichletBC.inc.hpp"