GridFunctionOperatorTransposed.hpp

#pragma once

#include <amdis/common/Transposed.hpp>

namespace AMDiS
{
  template <class Transposed>
  class GridFunctionLocalOperatorTransposed;

  template <class Transposed>
  class GridFunctionOperatorTransposed
  {
  public:
    GridFunctionOperatorTransposed(Transposed const& transposedOp)
      : transposedOp_(transposedOp)
    {}

    template <class GridView>
    void update(GridView const& gv)
    {
      transposedOp_.update(gv);
    }

    friend auto localOperator(GridFunctionOperatorTransposed const& op)
    {
      return GridFunctionLocalOperatorTransposed{localOperator(op.transposedOp_)};
    }

  private:
    Transposed transposedOp_;
  };


  template <class Transposed>
  class GridFunctionLocalOperatorTransposed
  {
  public:
    GridFunctionLocalOperatorTransposed(Transposed const& transposedLop)
      : transposedLop_(transposedLop)
    {}

    template <class Element>
    void bind(Element const& element)
    {
      transposedLop_.bind(element);
    }

    void unbind()
    {
      transposedLop_.unbind();
    }


    template <class CG, class RN, class CN, class Mat>
    void assemble(CG const& contextGeometry, RN const& rowNode, CN const& colNode,
                  Mat& elementMatrix) const
    {
      auto elementMatrixT = transposed(elementMatrix);
      transposedLop_.assemble(contextGeometry, colNode, rowNode, elementMatrixT);
    }

  private:
    Transposed transposedLop_;
  };

} // end namespace AMDiS