Operators.hpp 3.24 KB
Newer Older
1
2
#pragma once

3
4
#include <amdis/LocalAssembler.hpp>
#include <amdis/GridFunctionOperator.hpp>
5

6
/*
7
8
9
10
11
12
13
14
15
16
 * In the following comments we use the notation
 * psi ... scalar testfunction
 * Psi ... vector testfunction
 * phi ... scalar trialfunction
 * Phi ... vector trialfunction
 * A ..... matrix coefficient
 * b ..... vector coefficient
 * c ..... scalar coefficient
 */

17
18
19
20
21
22

/**
  * \defgroup operators Operator module
  * \brief Defines operators to be assembled in the matrix/vector
  *
  * An `Operator` is a class providing methods necessary for assembling:
Praetorius, Simon's avatar
Praetorius, Simon committed
23
  * - `bind(Element, Geometry)` and `unbind()` for binding an unbinding the
24
25
  *   element to (from) an GridView entity of codim 0. Additionally the Geometry
  *   object of the element is provided.
Praetorius, Simon's avatar
Praetorius, Simon committed
26
  * - `getQuadratureRule(Nodes...)` factory for the
27
28
29
  *   quadrature rules used in assembling the operator on the element. `Nodes...`
  *   is either `{RowNode, ColNode}` for Matrix-Operators or `{Node}` for a
  *   Vector-Operator.
Praetorius, Simon's avatar
Praetorius, Simon committed
30
  * - `calculateElementVector(ContextGeometry, QuadratureRule, ElementVector, Node)`
31
32
  *   where the `ContextGeometry` provides a reference to the ElementGeometry and
  *   geometry of the LocalContext (that can be different), *or*
Praetorius, Simon's avatar
Praetorius, Simon committed
33
  * - `calculateElementMatrix(ContextGeometry, QuadratureRule, ElementMatrix, RowNode, ColNode, Flags...)`
34
35
36
37
38
39
  *   Same as for `calculateElementVector` but additionally two optimization flags
  *   are provided as `bool_t<...>` type:
  *   + `sameFE`: the FiniteElementSpace of `RowNode` and `ColNode` are the same.
  *   + `sameNode`: the nodes are the same in the GlobalBasis-tree.
  **/

40
// zero-order operators
41
42
43
44
45
46
#include <amdis/assembler/ZeroOrderTest.hpp>             // <psi * c>
#include <amdis/assembler/ZeroOrderTestTrial.hpp>        // <psi, c * phi>
#include <amdis/assembler/ZeroOrderTestTrialvec.hpp>     // <psi, b * Phi>
#include <amdis/assembler/ZeroOrderTestvec.hpp>          // <Psi * b>
#include <amdis/assembler/ZeroOrderTestvecTrial.hpp>     // <Psi, b * phi>
#include <amdis/assembler/ZeroOrderTestvecTrialvec.hpp>  // <Psi, A * Phi>, <Psi, c * Phi>
47
48

// first-order operators
49
50
51
52
#include <amdis/assembler/FirstOrderPartialTest.hpp>      // <d_i(psi), c>
#include <amdis/assembler/FirstOrderGradTest.hpp>         // <grad(psi), b>
#include <amdis/assembler/FirstOrderDivTestvec.hpp>       // <div(Psi), c>

53
54
55
56
57
58
59
60
#include <amdis/assembler/FirstOrderDivTestvecTrial.hpp>   // <div(Psi), c * phi>
#include <amdis/assembler/FirstOrderGradTestTrial.hpp>     // <grad(psi), b * phi>
#include <amdis/assembler/FirstOrderGradTestTrialvec.hpp>  // <grad(psi), c * Phi>
#include <amdis/assembler/FirstOrderPartialTestTrial.hpp>  // <d_i(psi), c * psi>
#include <amdis/assembler/FirstOrderTestDivTrialvec.hpp>   // <psi, c * div(Phi)>
#include <amdis/assembler/FirstOrderTestGradTrial.hpp>     // <psi, b * grad(phi)>
#include <amdis/assembler/FirstOrderTestPartialTrial.hpp>  // <psi, c * d_i(phi)>
#include <amdis/assembler/FirstOrderTestvecGradTrial.hpp>  // <Psi, c * grad(phi)>
61
62

// second-order operators
63
64
65
#include <amdis/assembler/SecondOrderDivTestvecDivTrialvec.hpp>    // <div(Psi), c * div(Phi)>
#include <amdis/assembler/SecondOrderGradTestGradTrial.hpp>        // <grad(psi), A * grad(phi)>
#include <amdis/assembler/SecondOrderPartialTestPartialTrial.hpp>  // <d_i(psi), c * d_j(phi)>
66