SymmetricDirichletBC.hpp

#pragma once
 
#include <amdis/DirichletBC.hpp>
 
namespace AMDiS {
 
 
template <class Basis, class Path, class ValueGridFct>
class SymmetricDirichletBC
  : public DirichletBC<Basis, Path, Path, ValueGridFct>
{
  using Base = DirichletBC<Basis, Path, Path, ValueGridFct>;
  using GridView = typename Basis::GridView;
  using Intersection = typename GridView::Intersection;
 
public:
  // inherit constructors
  using Base::Base;
 
  template <class B>
  SymmetricDirichletBC(B&& basis, Path const& path,
                       BoundarySubset<Intersection> boundarySubset,
                       ValueGridFct values)
    : Base(FWD(basis), path, path, std::move(boundarySubset), std::move(values))
  {}
 
  template <class Mat, class Sol, class Rhs>
  void apply(Mat& matrix, Sol& solution, Rhs& rhs)
  {
    if (this->rowIndices_ != this->colIndices_)
      error_exit("SymmetricDirichletBC requires identical row/col DOF sets.");
    std::vector<typename Sol::value_type> solutionValues;
    solutionValues.reserve(this->colIndices_.size());
 
    {
      Sol boundarySolution{solution};
      valueOf(boundarySolution, this->col_).interpolate_noalias(this->valueGridFct_, tag::assign{});
      boundarySolution.gather(this->colIndices_, solutionValues);
    }
 
    solution.scatter(this->colIndices_, solutionValues);
    solution.finish();
 
    matrix.zeroRowsColumns(this->rowIndices_, true, solution, rhs);
 
    rhs.scatter(this->rowIndices_, solutionValues);
    rhs.finish();
  }
 
 
};
 
template <class B, class Path, class Values, class Basis = Underlying_t<B>,
          REQUIRES(Concepts::GlobalBasis<Basis>)>
SymmetricDirichletBC(B const&, Path const&,
                     BoundarySubset<typename Basis::GridView::Intersection>, Values const&)
  -> SymmetricDirichletBC<Basis, Path, Underlying_t<Values>>;
 
} // end namespace AMDiS