AssembleOperators.hpp

#pragma once

namespace AMDiS
{
  template <class ElementAssembler, class IntersectionAssembler, class BoundaryAssembler>
  struct AssemblerTriple
  {
    ElementAssembler elementAssembler;
    IntersectionAssembler intersectionAssembler;
    BoundaryAssembler boundaryAssembler;
  };

  template <class EA, class IA, class BA>
  AssemblerTriple<EA, IA, BA> makeAssemblerTriple(EA const& ea, IA const& ia, BA const& ba)
  {
    return {ea, ia, ba};
  }


  template <class GV, class Element, class Operators, class EA, class IA, class BA>
  void assembleOperators(GV const& gridView, Element const& element,
                         Operators& operators,
                         AssemblerTriple<EA,IA,BA> const& assemblerTriple)
  {
    // assemble element operators
    assemblerTriple.elementAssembler(element, operators.onElement());

    // assemble intersection operators
    if (!operators.onIntersection().empty()
        || (!operators.onBoundary().empty() && element.hasBoundaryIntersections()))
    {
      for (auto const& intersection : intersections(gridView, element)) {
        if (intersection.boundary())
          assemblerTriple.boundaryAssembler(intersection, operators.onBoundary());
        else
          assemblerTriple.intersectionAssembler(intersection, operators.onIntersection());
      }
    }
  }


  template <class Node, class Vec>
  auto makeVectorAssembler(Node const& node, Vec& elementVector)
  {
    return makeAssemblerTriple(
      [&](auto const& element, auto& operators) {
        for (auto& op : operators)
          op->assemble(element, node, elementVector);
      },
      [&](auto const& is, auto& operators) {
        for (auto& op : operators)
          op->assemble(is, node, elementVector);
      },
      [&](auto const& bis, auto& operators) {
        for (auto& data : operators) {
          if (data.bs(bis))
            data.op->assemble(bis, node, elementVector);
        }
      });
  }


  template <class RN, class CN, class Mat>
  auto makeMatrixAssembler(RN const& rowNode, CN const& colNode, Mat& elementMatrix)
  {
    return makeAssemblerTriple(
      [&](auto const& element, auto& operators) {
        for (auto& op : operators)
          op->assemble(element, rowNode, colNode, elementMatrix);
      },
      [&](auto const& is, auto& operators) {
        for (auto& op : operators)
          op->assemble(is, rowNode, colNode, elementMatrix);
      },
      [&](auto const& bis, auto& operators) {
        for (auto& data : operators) {
          if (data.bs(bis))
            data.op->assemble(bis, rowNode, colNode, elementMatrix);
        }
      });
  }

} // end namespace AMDiS