`:
+\\[
+\hat{U}(\lambda) := \frac{1}{2}\left(\hat{C}(\lambda)^2\,(1-\hat{C}(\lambda))^2 + \frac{1}{\epsilon}\|\Lambda^{-T}\_T\nabla\_\lambda \hat{C}(\lambda))\|^2\right)
+\\]
+
+Assign expression on rhs to DOFVector `\(U\)`:
+```
+U << 0.5*( pow<2>(valueOf(C) * (1.0 - valueOf(C))
+ + (1.0/eps) * unary_dot(gradientOf(C)) );
+```
+
+---
+
# Working with the discrete solution
- Reduce the `DOFVector`, i.e. calc integrals, norms:
```
diff --git a/expressions.md b/expressions.md
index 781f7eff8a3b48a4a01fd252bc640a7ed0f5abb4..6038a97cf0f0ac81b96cb8fbf03806390be126ee 100644
--- a/expressions.md
+++ b/expressions.md
@@ -37,18 +37,18 @@ In the following table operations are listed that can be applied to elemental ex
| `sqrt(T)` | The square-root of an expression |
| `exp(T)` | The exponential function applied to the evaluated expression |
| `log(T)` | The natural logarithm applied to an evaluated expression. |
-| `cos(T), sin(T), tan(T)` | Der Cosinus, Sinus, bzw. Tangens der Auswertung des Terms T. |
-| `acos(T), asin(T), atan(T)` | Der Arkus-Cosinus, Arkus-Sinus, bzw. Arkus Tangens der Auswertung des Terms T. |
-| `atan2(T1, T2)` | Der Arkus-Tangens 2 = atan(T1 / T2). |
-| `cosh(T), sinh(T), tanh(T)` | Der Cosinus-Hyperbolicus, Sinus-Hyperbolicus, bzw. Tangens-Hyperbolicus der Auswertung des Terms T. |
-| `acosh(T), asinh(T), atanh(T)` | Der Arkus Cosinus-Hyperbolicus, Arkus Sinus-Hyperbolicus, Arkus Tangens-Hyperbolicus der Auswertung des Terms T. |
-| `max(T1, T2), min(T1, T2)` | Das Maximum/Minimum der Auswertungen von T1, bzw. T2. |
-| `abs_(T), signum(T)` | Der Absolutbetrag von T, bzw. das Vorzeichen (`T < 0 => signum(T) := -1, T>0 => signum(T) := 1, T==0 => signum(T) := 0`) |
-| `clamp(T, lo, hi)` |
-| `ceil(T), floor(T)` | die kleines ganze Zahl größer, bzw. die größte ganze Zahl kleiner als Wert von T |
-| `function_(F, T1, T2, T3, ...)` | Die Anwendung eines Funktors F auf die Auswertung der Terme T1,T2,... | If `T` compares less than `lo`, returns `lo`; otherwise if `hi` compares less than `T`, returns `hi`; otherwise returns `T`
+| `cos(T), sin(T), tan(T)` | Cosine, sine, and tangens applied to an evaluated expression. |
+| `acos(T), asin(T), atan(T)` | Arccosine, Arcsine, and arctangent applied to an evaluated expression |
+| `atan2(T1, T2)` | The atan2 function, i.e. arctan(T1 / T2). |
+| `cosh(T), sinh(T), tanh(T)` | Hyperbolic cosine, hyperbolic sine, and hyperbolic tangent. |
+| `acosh(T), asinh(T), atanh(T)` | Inverse hyperbolic functions applied to an evaluated expression. |
+| `max(T1, T2), min(T1, T2)` | The maximum/minimum of two evaluated expressions T1 and T2. |
+| `abs_(T), signum(T)` | The absolute value and the sign (`T < 0 => signum(T) := -1, T>0 => signum(T) := 1, T==0 => signum(T) := 0`) |
+| `clamp(T, lo, hi)` | Applies the `std::clamp` function locally to the evaluated expression `T`, where `lo` and `hi` are fixed values. |
+| `ceil(T), floor(T)` | Round down or up the evaluated expression. |
+| `function_(F, T1, T2, T3, ...)` | Apply a functor to the evaluated expressions `T1,T2,...` |
-Ein Funktor ist dabei eine Klasse mit folgender Struktur:
+A functor is a class with the following structure:
```c++
struct Functor : public FunctorBase
{
@@ -58,29 +58,30 @@ struct Functor : public FunctorBase
value_type operator()(const T1::value_type&, const T2::value_type&, ...) const { return (...); }
};
```
-
-Die Argumente, die an die Funktion `getDegree` übergeben werden sind die Polynomgrade der Terme:
-
+or any valid function object in c++. When it is derived from `FunctorBase` one can specify an polynomial degree of the functor, relative to
+the polynomial degrees of the arguments passed to the functor, i.e. the polynomial degrees of the passed expressions.
+The `getDegree()` functor is then evaluated in the following form:
```c++
getDegree(T1.getDegree(), T2.getDegree(), ...)
```
-### Vektor-/Matrix-Ausdrücke
-Für vektor- bzw. matrixwertige Term, wie z.B. `gradientOf(DV)` gibt es eine Reihe von Ausdrücken / Operationen, die im Folgenden aufgelistet sind. Dabei bezeichnet `V` eine vektorwerte Expression und `M` eine matrixwertige Expressions.
+### Vektor-/Matrix-Expressions
+For vector- and matrix-valued expressions, like, e.g., `gradientOf(DV)` one can apply functions that act on the vectors/matrices on
+evaluation. In the following list, the notation `V` refers to a vector expressions and `M` to a matrix expression:
| Expression | Semantics |
| ---------- | --------- |
-| `+, -` | Elementare arithmetische Ausdrücke (Elementweise) |
-| `unary_dot(V)` | Skalarprodukt eines vektorwertigen Terms mit sich selbst: `result = V^H * V`. |
-| `dot(V1, V2)` | Skalarprodukt zweier vektorwertigen Terme: `result = V1^H * V2`. |
-| `one_norm(V)` | Die 1-Norm eines Vektors `result = sum_i(abs(V_i))`. |
-| `one_norm(M)` | Die 1-Norm einer Matrix `result = max_j(sum_i(abs(M_ij)))`. |
-| `two_norm(V)` | Die 2-Norm eines Vektors `result = sqrt(V^H * V)`. |
-| `p_norm(V)` | Die p-Norm eines Vektors `result = [sum_i(abs(v_i)^p)]^(1/p)`. |
-| `cross(V1, V2)` | Kreuzprodukt zweier vektorwertigen Terme: `result = V1 x V2`. |
-| `diagonal(V)` | Diagonalmatrix aus einträgen eines vektorwertigen Terms: `matrix = diagonal(V)`. |
-| `outer(V1, V2)` | Äußeres Produkt (dyadisches Produkt / Tensorprodukt) zweier vektorwertigen Terme: `matrix = V1 * V2^T`. |
-| `trans(M)` | Das Transponierte eines matrixwertigen Terms: `result = M^T`. |
-| `at(V, i)` | Zugriff auf eine Komponente eines Vektors: `result = V_i`. |
-| `at(M, i, j)` | Zugriff auf eine Komponente einer Matrix: `result = M_ij`. |
+| `+, -` | Arithmetic operations (elementwise) |
+| `unary_dot(V)` | Scalarprodukt (dorproduct) of a vector with itself: `result = V^H * V`. |
+| `dot(V1, V2)` | Scalarprodukt (dorproduct) of two vectors: `result = V1^H * V2`. |
+| `one_norm(V)` | The 1-norm of a vectors `result = sum_i(abs(V_i))`. |
+| `one_norm(M)` | The 1-norm of a matrix `result = max_j(sum_i(abs(M_ij)))`. |
+| `two_norm(V)` | The 2-norm of a vector `result = sqrt(V^H * V)`. |
+| `p_norm
(V)` | The p-norm of a vector `result = [sum_i(abs(v_i)^p)]^(1/p)`. |
+| `cross(V1, V2)` | Crossproduct of two vectors: `result = V1 x V2`. |
+| `diagonal(V)` | Diagonal matrix with diagonal entries of the passed vector: `matrix = diagonal(V)`. |
+| `outer(V1, V2)` | Outer product (dyadic product / tensorproduct) of two vectors: `matrix = V1 * V2^T`. |
+| `trans(M)` | The transposed matrix: `result = M^T`. |
+| `at(V, i)` | Access a component of a vector: `result = V_i`. |
+| `at(M, i, j)` | Access a component of a matrix: `result = M_ij`. |
diff --git a/material b/material
index af1c8568b5158284b56e49d052c6df6a33a8487c..46df70941b96c72c9c9b6478625e421453a05244 160000
--- a/material
+++ b/material
@@ -1 +1 @@
-Subproject commit af1c8568b5158284b56e49d052c6df6a33a8487c
+Subproject commit 46df70941b96c72c9c9b6478625e421453a05244