Commit e18609d3 authored by Praetorius, Simon's avatar Praetorius, Simon

corrected error in quadrature degree, restructuring of zero/first/secondOrderAssembler

parent 781a6094
......@@ -24,6 +24,7 @@ namespace AMDiS
using GridView = typename GlobalBasis::GridView;
public:
/// Constructor, stores a shared-pointer to the feSpaces
Assembler(GlobalBasis& globalBasis,
MatrixOperators<GlobalBasis>& matrixOperators,
......@@ -48,7 +49,9 @@ namespace AMDiS
SystemVectorType& rhs,
bool asmMatrix, bool asmVector);
private:
/// Sets the system to zero and initializes all operators and boundary conditions
template <class SystemMatrixType, class SystemVectorType>
void initMatrixVector(
......@@ -58,11 +61,12 @@ namespace AMDiS
bool asmMatrix, bool asmVector) const;
template <class ElementContainer, class Container, class Operators, class... Bases>
template <class ElementContainer, class Container, class Operators, class Geometry, class... Bases>
void assembleElementOperators(
ElementContainer& elementContainer,
Container& container,
Operators& operators,
Geometry const& geometry,
Bases const&... subBases) const;
......@@ -90,22 +94,9 @@ namespace AMDiS
return globalBasis_.gridView();
}
public:
template <class RowNode, class ColNode>
Flag optimizationFlags(RowNode const& rowNode, ColNode const& colNode) const
{
Flag flag;
if (rowNode.treeIndex() == colNode.treeIndex())
flag |= EQUAL_BASES;
// NOTE: find a way to compare localBases directly
// if (rowNode.finiteElement().localBasis().order() == colNode.finiteElement().localBasis().order())
// flag |= EQUAL_LOCALBASES;
return flag;
}
private:
GlobalBasis& globalBasis_;
MatrixOperators<GlobalBasis>& matrixOperators_;
VectorOperators<GlobalBasis>& rhsOperators_;
......
......@@ -23,8 +23,8 @@ void Assembler<GlobalBasis>::assemble(
// 2. create a local matrix and vector
std::size_t localSize = localView.maxSize();
mtl::dense2D<double> elementMatrix(localSize, localSize);
mtl::dense_vector<double> elementVector(localSize);
Impl::ElementMatrix elementMatrix(localSize, localSize);
Impl::ElementVector elementVector(localSize);
// 3. traverse grid and assemble operators on the elements
for (auto const& element : elements(globalBasis_.gridView()))
......@@ -33,6 +33,7 @@ void Assembler<GlobalBasis>::assemble(
set_to_zero(elementVector);
localView.bind(element);
auto geometry = element.geometry();
// traverse type-tree of global-basis
forEachNode(localView.tree(), [&,this](auto const& rowNode, auto rowTreePath)
......@@ -43,7 +44,7 @@ void Assembler<GlobalBasis>::assemble(
auto& rhsOp = rhsOperators_[rowNode];
if (rhsOp.assemble(asmVector) && !rhsOp.empty())
assembleElementOperators(elementVector, rhs, rhsOp, rowLocalView);
assembleElementOperators(elementVector, rhs, rhsOp, geometry, rowLocalView);
forEachNode(localView.tree(), [&,this](auto const& colNode, auto colTreePath)
{
......@@ -53,8 +54,7 @@ void Assembler<GlobalBasis>::assemble(
auto colLocalView = colBasis.localView();
colLocalView.bind(element); // NOTE: Is this necessary
assembleElementOperators(elementMatrix, matrix, matOp, rowLocalView, colLocalView,
optimizationFlags(rowNode, colNode));
assembleElementOperators(elementMatrix, matrix, matOp, geometry, rowLocalView, colLocalView);
}
});
});
......@@ -92,11 +92,12 @@ void Assembler<GlobalBasis>::assemble(
template <class GlobalBasis>
template <class ElementContainer, class Container, class Operators, class... LocalViews>
template <class ElementContainer, class Container, class Operators, class Geometry, class... LocalViews>
void Assembler<GlobalBasis>::assembleElementOperators(
ElementContainer& elementContainer,
Container& container,
Operators& operators,
Geometry const& geometry,
LocalViews const&... localViews) const
{
auto const& element = getElement(localViews...);
......@@ -106,7 +107,9 @@ void Assembler<GlobalBasis>::assembleElementOperators(
auto assemble_operators = [&](auto const& context, auto& operator_list) {
for (auto scaled : operator_list) {
bool add_op = scaled.op->assemble(context, elementContainer, localViews..., scaled.factor);
scaled.op->bind(element, geometry);
bool add_op = scaled.op->assemble(context, elementContainer, localViews.tree()..., scaled.factor);
scaled.op->unbind();
add = add || add_op;
}
};
......@@ -147,14 +150,14 @@ void Assembler<GlobalBasis>::initMatrixVector(
msg(0, " DOFs for Basis[", to_string(rowTreePath), "]"); // TODO: add right values
auto rowBasis = Dune::Functions::subspaceBasis(globalBasis_, rowTreePath);
if (rhsOperators_[rowNode].assemble(asmVector))
rhsOperators_[rowNode].init(rowBasis);
//if (rhsOperators_[rowNode].assemble(asmVector))
// rhsOperators_[rowNode].init(rowBasis);
forEachNode(localView.tree(), [&,this](auto const& colNode, auto colTreePath)
{
auto colBasis = Dune::Functions::subspaceBasis(globalBasis_, colTreePath);
if (matrixOperators_[rowNode][colNode].assemble(asmMatrix))
matrixOperators_[rowNode][colNode].init(rowBasis, colBasis);
//if (matrixOperators_[rowNode][colNode].assemble(asmMatrix))
// matrixOperators_[rowNode][colNode].init(rowBasis, colBasis);
for (auto bc : constraints_[rowNode][colNode].scalar)
bc->init(matrix, solution, rhs, rowBasis, colBasis);
......
This diff is collapsed.
......@@ -18,19 +18,36 @@ namespace AMDiS
using LocalQuadratureRules = Dune::QuadratureRules<ctype, LocalContext::mydimension>;
using QuadratureRule = QuadratureRuleFactory_t<LocalContext, ctype, dim>;
using Geometry = typename Impl::Get<LocalContext>::Geometry;
using Geometry = typename GridView::template Codim<0>::Entity::Geometry;
using LocalGeometry = typename Impl::Get<LocalContext>::Geometry;
public:
LocalAssembler(int degree, FirstOrderType type = GRD_PHI)
: degree_(degree)
, type_(type)
{}
/// Constructor, initializes the geometry of the element and a
/// quadrature-rule wrapper
template <class Operator>
LocalAssembler(Operator& op, LocalContext const& element, int degree, FirstOrderType type = GRD_PHI)
: geometry(get_geometry(element))
void bind(Operator& op, LocalContext const& localContext, Geometry const& geometry, LocalGeometry const& localGeometry)
{
int order = op.getQuadratureDegree(geometry.type(), geometry, degree, type);
auto const& quad = LocalQuadratureRules::rule(geometry.type(), order);
localContext_ = &localContext;
geometry_ = &geometry;
localGeometry_ = &localGeometry;
int order = op.getQuadratureDegree(localGeometry.type(), localGeometry, degree_, type_);
auto const& quad = LocalQuadratureRules::rule(localGeometry.type(), order);
quadrature_.reset(new QuadratureRule(localContext, quad));
}
quadrature.reset(new QuadratureRule(element, quad));
void unbind()
{
localContext_ = nullptr;
geometry_ = nullptr;
localGeometry_ = nullptr;
}
/// \brief Returns reference to the transformed quadrature rule
......@@ -42,34 +59,44 @@ namespace AMDiS
**/
QuadratureRule const& getQuadrature() const
{
return *quadrature;
assert( quadrature_ );
return *quadrature_;
}
LocalContext const& getLocalContext() const
{
assert( localContext_ );
return *localContext_;
}
/// Return the geometry of the Object
/**
* The geometry is either the element geometry, or the geometry of the
* inside-element for intersections.
**/
Geometry const& getGeometry() const
{
return geometry;
assert( geometry_ );
return *geometry_;
}
protected:
LocalGeometry const& getLocalGeometry() const
{
assert( localGeometry_ );
return *localGeometry_;
}
// transform coords from intersection coords to element coords
template <class Coordinate>
decltype(auto) map(Coordinate const& p) const
decltype(auto) getLocal(Coordinate const& p) const
{
return get_position<LocalContext>(geometry, p);
return get_position<LocalContext>(getLocalGeometry(), p);
}
private:
/// transformed quadrature rule
std::shared_ptr<QuadratureRule const> quadrature;
int degree_;
FirstOrderType type_;
/// geometry() for entities or geometryInInside() for intersections
Geometry geometry;
LocalContext const* localContext_ = nullptr;
Geometry const* geometry_ = nullptr;
LocalGeometry const* localGeometry_ = nullptr;
/// transformed quadrature rule
std::shared_ptr<QuadratureRule const> quadrature_;
};
} // end namespace AMDiS
......@@ -27,11 +27,22 @@ namespace AMDiS
using Self = Operator;
using OperatorTermType = OperatorTerm<LocalContext>;
using Element = typename GridView::template Codim<0>::Entity;
using Geometry = typename Element::Geometry;
using LocalGeometry = typename Impl::Get<LocalContext>::Geometry;
using ElementVector = Impl::ElementVector;
using ElementMatrix = Impl::ElementMatrix;
using QuadratureRule = QuadratureRuleFactory_t<LocalContext, typename GridView::ctype, GridView::dimension>;
template <class,class> friend class ZeroOrderAssembler;
template <class,class, FirstOrderType> friend class FirstOrderAssembler;
template <class,class> friend class SecondOrderAssembler;
public:
/// \brief Add coefficients for zero-order operator < C(phi), psi >.
/**
* If `c` is a scalar expression, then C(phi) := c * phi,
......@@ -113,38 +124,77 @@ namespace AMDiS
public: // initialize and assemble operator on element
/// Extract the polynomial degree from \p rowBasis and \p colBasis.
template <class RowBasis, class ColBasis>
void init(RowBasis const& rowBasis,
ColBasis const& colBasis);
template <class RowNode, class ColNode>
void init(RowNode const& rowNode, ColNode const& colNode);
template <class RowNode>
void init(RowNode const& node);
void bind(Element const& element, Geometry const& geometry)
{
element_ = &element;
geometry_ = &geometry;
}
template <class RowBasis>
void init(RowBasis const& rowBasis);
void unbind()
{
element_ = nullptr;
geometry_ = nullptr;
}
Element const& getElement() const
{
assert( element_ );
return *element_;
}
Geometry const& getGeometry() const
{
assert( geometry_ );
return *geometry_;
}
decltype(auto) getLocalGeometry(LocalContext const& context) const
{
return getLocalGeometry(context, std::is_same<LocalContext, Element>{});
}
private: // implementation detail
Geometry const& getLocalGeometry(Element const& element, std::true_type) const
{
return *geometry_;
}
LocalGeometry getLocalGeometry(LocalContext const& intersection, std::false_type) const
{
return intersection.geometryInInside();
}
public:
/// Calculates the needed quadrature degree for the given term-order \p order.
/// This takes into account the polynomial degree of trial and test functions
/// and the polynomial degree of the coefficient functions
template <class Geometry>
int getQuadratureDegree(Dune::GeometryType t, Geometry const& geometry, int order,
int getQuadratureDegree(Dune::GeometryType t,
LocalGeometry const& geometry, int order,
FirstOrderType firstOrderType = GRD_PHI);
// assemble matrix operator
template <class RowView, class ColView, class ElementMatrix>
template <class RowNode, class ColNode>
bool assemble(
LocalContext const& element,
ElementMatrix& elementMatrix,
RowView const& rowView,
ColView const& colView,
Flag const& optimizationFlag,
RowNode const& rowNode,
ColNode const& colNode,
double* factor = NULL);
// assemble vector operator
template <class LocalView, class ElementVector>
template <class RowNode>
bool assemble(
LocalContext const& element,
ElementVector& elementVector,
LocalView const& localView,
RowNode const& node,
double* factor = NULL);
......@@ -168,8 +218,8 @@ namespace AMDiS
protected: // sum up constribution from all operator-terms
template <class OrderTag, class E, class Quadrature>
void init(OrderTag, E const& element, Quadrature const& quad)
template <class OrderTag>
void init(OrderTag, LocalContext const& element, QuadratureRule const& quad)
{
for (auto* operatorTerm : getOperatorTerms(OrderTag{}))
operatorTerm->init(element, quad);
......@@ -182,6 +232,7 @@ namespace AMDiS
result += operatorTerm->eval(iq, args...) * factor;
}
private:
std::list<OperatorTermType*>& getOperatorTerms(tag::zot) { return zeroOrder; }
......@@ -189,12 +240,6 @@ namespace AMDiS
std::list<OperatorTermType*>& getOperatorTerms(tag::fot_grd_psi) { return firstOrderGrdPsi; }
std::list<OperatorTermType*>& getOperatorTerms(tag::sot) { return secondOrder; }
template <class LocalView>
std::size_t getElementIndex(GridView const& gridView, LocalView const& localView) const
{
return gridView.indexSet().index(localView.element());
}
private:
......@@ -210,11 +255,16 @@ namespace AMDiS
/// List of all zero order terms
std::list<OperatorTermType*> zeroOrder;
int psiDegree = 1;
int phiDegree = 1;
int psiDegree_ = 1;
int phiDegree_ = 1;
Element const* element_ = nullptr;
Geometry const* geometry_ = nullptr;
std::size_t lastMatrixIndex = 0;
std::size_t lastVectorIndex = 0;
ZeroOrderAssembler<GridView, LocalContext> zeroOrderAssembler;
FirstOrderAssembler<GridView, LocalContext, GRD_PHI> firstOrderGrdPhiAssembler;
FirstOrderAssembler<GridView, LocalContext, GRD_PSI> firstOrderGrdPsiAssembler;
SecondOrderAssembler<GridView, LocalContext> secondOrderAssembler;
};
......
......@@ -2,41 +2,28 @@
namespace AMDiS {
template <class GridView, class Element>
template <class RowBasis, class ColBasis>
void Operator<GridView, Element>::
init(RowBasis const& rowBasis, ColBasis const& colBasis)
template <class GridView, class LocalContext>
template <class RowNode, class ColNode>
void Operator<GridView, LocalContext>::init(
RowNode const& rowNode,
ColNode const& colNode)
{
lastMatrixIndex = std::numeric_limits<std::size_t>::max();
lastVectorIndex = std::numeric_limits<std::size_t>::max();
// auto const& rowFE = rowView.tree().finiteElement();
// auto const& colFE = colView.tree().finiteElement();
// psiDegree = rowFE.localBasis().order();
// phiDegree = colFE.localBasis().order();
psiDegree = getPolynomialDegree<RowBasis>;
phiDegree = getPolynomialDegree<ColBasis>;
// TODO: calc quadrature degree here.
psiDegree_ = getPolynomialDegree(rowNode);
phiDegree_ = getPolynomialDegree(colNode);
}
template <class GridView, class Element>
template <class RowBasis>
void Operator<GridView, Element>::
init(RowBasis const& rowBasis)
template <class GridView, class LocalContext>
template <class RowNode>
void Operator<GridView, LocalContext>::init(RowNode const& node)
{
lastVectorIndex = std::numeric_limits<std::size_t>::max();
psiDegree = getPolynomialDegree<RowBasis>;
psiDegree_ = getPolynomialDegree(node);
}
template <class GridView, class Element>
template <class Geometry>
int Operator<GridView, Element>::
getQuadratureDegree(Dune::GeometryType t, Geometry const& geometry, int order, FirstOrderType type)
template <class GridView, class LocalContext>
int Operator<GridView, LocalContext>::
getQuadratureDegree(Dune::GeometryType t, LocalGeometry const& geometry, int order, FirstOrderType type)
{
std::list<OperatorTermType*>* terms = NULL;
......@@ -60,7 +47,7 @@ getQuadratureDegree(Dune::GeometryType t, Geometry const& geometry, int order, F
for (OperatorTermType* term : *terms)
maxTermDegree = std::max(maxTermDegree, term->getDegree(t));
int degree = psiDegree + phiDegree + maxTermDegree;
int degree = psiDegree_ + phiDegree_ + maxTermDegree;
if (t.isSimplex())
degree -= order;
......@@ -71,14 +58,13 @@ getQuadratureDegree(Dune::GeometryType t, Geometry const& geometry, int order, F
}
template <class GridView, class Element>
template <class RowView, class ColView, class ElementMatrix>
bool Operator<GridView, Element>::assemble(
Element const& element,
template <class GridView, class LocalContext>
template <class RowNode, class ColNode>
bool Operator<GridView, LocalContext>::assemble(
LocalContext const& context,
ElementMatrix& elementMatrix,
RowView const& rowView,
ColView const& colView,
Flag const& /*optimizationFlag*/,
RowNode const& rowNode,
ColNode const& colNode,
double* factor)
{
double fac = factor ? *factor : 1.0;
......@@ -86,33 +72,41 @@ bool Operator<GridView, Element>::assemble(
if (fac == 0.0)
return false;
init(rowNode, colNode);
auto&& geometry = getGeometry();
auto&& quad_geometry = getLocalGeometry(context);
if (!zeroOrder.empty()) {
ZeroOrderAssembler<GridView, Element> assembler(*this, element);
assembler.calculateElementMatrix(*this, rowView, colView, elementMatrix, fac);
zeroOrderAssembler.bind(fac, *this, context, geometry, quad_geometry);
zeroOrderAssembler.calculateElementMatrix(*this, elementMatrix, rowNode, colNode);
zeroOrderAssembler.unbind();
}
if (!firstOrderGrdPhi.empty()) {
FirstOrderAssembler<GridView, Element, GRD_PHI> assembler(*this, element);
assembler.calculateElementMatrix(*this, rowView, colView, elementMatrix, fac);
firstOrderGrdPhiAssembler.bind(fac, *this, context, geometry, quad_geometry);
firstOrderGrdPhiAssembler.calculateElementMatrix(*this, elementMatrix, rowNode, colNode);
firstOrderGrdPhiAssembler.unbind();
}
if (!firstOrderGrdPsi.empty()) {
FirstOrderAssembler<GridView, Element, GRD_PSI> assembler(*this, element);
assembler.calculateElementMatrix(*this, rowView, colView, elementMatrix, fac);
firstOrderGrdPsiAssembler.bind(fac, *this, context, geometry, quad_geometry);
firstOrderGrdPsiAssembler.calculateElementMatrix(*this, elementMatrix, rowNode, colNode);
firstOrderGrdPsiAssembler.unbind();
}
if (!secondOrder.empty()) {
SecondOrderAssembler<GridView, Element> assembler(*this, element);
assembler.calculateElementMatrix(*this, rowView, colView, elementMatrix, fac);
secondOrderAssembler.bind(fac, *this, context, geometry, quad_geometry);
secondOrderAssembler.calculateElementMatrix(*this, elementMatrix, rowNode, colNode);
secondOrderAssembler.unbind();
}
return true;
}
template <class GridView, class Element>
template <class LocalView, class ElementVector>
bool Operator<GridView, Element>::assemble(
Element const& element,
template <class GridView, class LocalContext>
template <class RowNode>
bool Operator<GridView, LocalContext>::assemble(
LocalContext const& context,
ElementVector& elementVector,
LocalView const& localView,
RowNode const& node,
double* factor)
{
double fac = factor ? *factor : 1.0;
......@@ -120,38 +114,44 @@ bool Operator<GridView, Element>::assemble(
if (fac == 0.0)
return false;
test_exit( firstOrderGrdPhi.empty() && secondOrder.empty(),
"Derivatives on ansatz-functions not allowed on the vector-side!");
test_exit(firstOrderGrdPhi.empty() && secondOrder.empty(),
"Derivatives on ansatz-functions not allowed on the vector-side!");
init(node);
auto&& geometry = getGeometry();
auto&& quad_geometry = getLocalGeometry(context);
if (!zeroOrder.empty()) {
ZeroOrderAssembler<GridView, Element> assembler(*this, element);
assembler.calculateElementVector(*this, localView, elementVector, fac);
zeroOrderAssembler.bind(fac, *this, context, geometry, quad_geometry);
zeroOrderAssembler.calculateElementVector(*this, elementVector, node);
zeroOrderAssembler.unbind();
}
if (!firstOrderGrdPsi.empty()) {
FirstOrderAssembler<GridView, Element, GRD_PSI> assembler(*this, element);
assembler.calculateElementVector(*this, localView, elementVector, fac);
firstOrderGrdPsiAssembler.bind(fac, *this, context, geometry, quad_geometry);
firstOrderGrdPsiAssembler.calculateElementVector(*this, elementVector, node);
firstOrderGrdPsiAssembler.unbind();
}
return true;
}
template <class GridView, class Element>
template <class GridView, class LocalContext>
template <class Term>
Operator<GridView, Element>& Operator<GridView, Element>::
Operator<GridView, LocalContext>& Operator<GridView, LocalContext>::
addZOTImpl(Term const& term)
{
zeroOrder.push_back(new GenericOperatorTerm<Element, Term>(term));
zeroOrder.push_back(new GenericOperatorTerm<LocalContext, Term>(term));
return *this;
}
template <class GridView, class Element>
template <class GridView, class LocalContext>
template <class Term>
Operator<GridView, Element>& Operator<GridView, Element>::
Operator<GridView, LocalContext>& Operator<GridView, LocalContext>::
addFOTImpl(Term const& term, FirstOrderType type)
{
using OpTerm = GenericOperatorTerm<Element, Term>;
using OpTerm = GenericOperatorTerm<LocalContext, Term>;
if (type == GRD_PHI)
firstOrderGrdPhi.push_back(new OpTerm(term));
else
......@@ -160,12 +160,12 @@ addFOTImpl(Term const& term, FirstOrderType type)
}
template <class GridView, class Element>
template <class GridView, class LocalContext>
template <class Term>
Operator<GridView, Element>& Operator<GridView, Element>::
Operator<GridView, LocalContext>& Operator<GridView, LocalContext>::
addFOTImpl(Term const& term, std::size_t i, FirstOrderType type)
{
using OpTerm = GenericOperatorTerm<Element, Term, VectorComponent>;
using OpTerm = GenericOperatorTerm<LocalContext, Term, VectorComponent>;
if (type == GRD_PHI)
firstOrderGrdPhi.push_back(new OpTerm(term, {i}));
......@@ -175,22 +175,22 @@ addFOTImpl(Term const& term, std::size_t i, FirstOrderType type)
}
template <class GridView, class Element>
template <class GridView, class LocalContext>
template <class Term>
Operator<GridView, Element>& Operator<GridView, Element>::
Operator<GridView, LocalContext>& Operator<GridView, LocalContext>::
addSOTImpl(Term const& term)
{
secondOrder.push_back(new GenericOperatorTerm<Element, Term>(term));
secondOrder.push_back(new GenericOperatorTerm<LocalContext, Term>(term));
return *this;
}
template <class GridView, class Element>
template <class GridView, class LocalContext>
template <class Term>
Operator<GridView, Element>& Operator<GridView, Element>::
Operator<GridView, LocalContext>& Operator<GridView, LocalContext>::
addSOTImpl(Term const& term, std::size_t i, std::size_t j)
{
using OpTerm = GenericOperatorTerm<Element, Term, MatrixComponent>;
using OpTerm = GenericOperatorTerm<LocalContext, Term, MatrixComponent>;
secondOrder.push_back(new OpTerm(term, {i,j}));
return *this;
}
......
......@@ -24,40 +24,40 @@ namespace AMDiS
using ElementVector = Impl::ElementVector;
public:
template <class Operator>
SecondOrderAssembler(Operator& op, LocalContext const& element)
: Super(op, element, 2)
SecondOrderAssembler()
: Super(2)
{}
template <class Operator, class... Args>
void bind(double factor, Operator& op, LocalContext const& localContext, Args&&... args)
{
op.init(tag::sot{}, element, Super::getQuadrature());
Super::bind(op, localContext, std::forward<Args>(args)...);
factor_ = factor;
op.init(tag::sot{}, localContext, Super::getQuadrature());
}
template <class Operator, class RowView, class ColView>
template <class Operator, class RowNode, class ColNode>
void calculateElementMatrix(Operator& op,
RowView const& rowView,
ColView const& colView,
ElementMatrix& elementMatrix,
double fac)
RowNode const& rowNode,
ColNode const& colNode)
{
using RowNode = typename RowView::Tree;
using ColNode = typename ColView::Tree;
calculateElementMatrix(op, rowView, colView, elementMatrix, fac,
calculateElementMatrix(op, elementMatrix, rowNode, colNode,
typename RowNode::NodeTag{}, typename ColNode::NodeTag{});
}
template <class Operator, class RowView, class ColView>
template <class Operator, class RowNode, class ColNode>
void calculateElementMatrix(Operator& op,
RowView const& rowView,
ColView const& colView,
ElementMatrix& elementMatrix,
double fac,
RowNode const& rowNode,
ColNode const& colNode,
Dune::TypeTree::LeafNodeTag,
Dune::TypeTree::LeafNodeTag)
{
auto geometry = rowView.element().geometry();
auto const& quad_geometry = Super::getGeometry();
auto const& rowLocalFE = rowView.tree().finiteElement();
auto const& colLocalFE = colView.tree().finiteElement();
auto const& rowLocalFE = rowNode.finiteElement();
auto const& colLocalFE = colNode.finiteElement();
int psiDegree = rowLocalFE.localBasis().order();
int phiDegree = colLocalFE.localBasis().order();
......@@ -69,17 +69,17 @@ namespace AMDiS
for (std::size_t iq = 0; iq < quad.size(); ++iq) {
// Position of the current quadrature point in the reference element
decltype(auto) quadPos <