DirichletBC.hpp

#pragma once

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

#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 Basis, class RowPath, class ColPath, class ValueGridFct>
  class DirichletBC
  {
    using GridView = typename Basis::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 B>
    DirichletBC(B&& basis, RowPath const& row, ColPath const& col,
                BoundarySubset<Intersection> boundarySubset, ValueGridFct values)
      : basis_{wrap_or_share(FWD(basis))}
      , row_{row}
      , col_{col}
      , boundarySubset_(std::move(boundarySubset))
      , valueGridFct_(std::move(values))
    {}

    template <class B>
    DirichletBC(B&& basis, BoundarySubset<Intersection> boundarySubset, ValueGridFct values)
      : DirichletBC(FWD(basis), makeTreePath(), makeTreePath(),
                    std::move(boundarySubset), std::move(values))
    {}



    void init();


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

  private:
    std::shared_ptr<Basis const> basis_;
    RowPath row_;
    ColPath col_;
    BoundarySubset<Intersection> boundarySubset_;
    ValueGridFct valueGridFct_;

    std::vector<typename Basis::MultiIndex> rowIndices_;
    std::vector<typename Basis::MultiIndex> colIndices_;
  };

  // deduction guides

  // Make a DirichletBC from a basis with treepath arguments
  template <class B, class Row, class Col, class Values, class Basis = Underlying_t<B>,
    REQUIRES(Concepts::GlobalBasis<Basis>)>
  DirichletBC(B const&, Row const&, Col const&, BoundarySubset<typename Basis::GridView::Intersection>, Values const&)
    -> DirichletBC<Basis, Row, Col, Underlying_t<Values>>;

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

} // end namespace AMDiS

#include "DirichletBC.inc.hpp"