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);
 
    template <class, class, class>
    friend class SymmetricDirichletBC;
 
  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"