Separate solver tolerances for each dof type

[TTitscher]

Problem

In monolithic multi-physics problems, different dof types may correspond to different dimensions. This may result in different magnitudes of the residual function. Imagine, we calculate in SI base units an one residual is in the order of 1e5 [Newton] and another one in 1e-8 [Volt]. Both differ in many orders of magnitude and should not be evaluated with the same tolerance.

Solution

One idea based on the current implementation:

• store a scaling factor for each dof type and apply before taking the norm of the whole R vector, as

  for (auto dof : dofs)
  residual[dof] *= scaling[dof];
  return ToEigen(residual, dofs).norm();

or as in oldNuTo

• use a DofContainer<double> to store the tolerances
• calculate the Norm(R) as DofContainer<double>
  • optional: add DofVector<double>::Norm()
• introduce bool operator<(const DofContainer<double>& lhs, const DofContainer<double>& rhs)
  • DofContainer now has to know its dofs (not implemented currently)
• (optional) introduce a typedef/class for DofContainer<double> to collect the methods

---

In the end, I do not care about the details. But I think this is an essential feature.

[TTitscher]

As pointed out by @joergfunger, the evaluation of the residual does not help the solver to actually solve the mixed problem. So the above options are pointless and we need something like a preconditioner. Some quick ideas:

• apply the scaling (to R and dR/du) in the integrand
• apply the scaling to the global system, e.g. at the assembly

[joergfunger]

The above mentioned procedure (just take the norm of each individual residual) works generally well for the implicit problems with direct solvers, because they are very robust with respect to the condition number of the matrix. For iterative solvers or when using an explicit time integration scheme, we should use a preconditioner. There are many preconditioners available that differ in the complexity of their computation and the benefit with respect to the condition number of the problem, but almost all (apart from the very simple one that applies a constant scaling factor for each dof type) work on the global matrices (or some part of it), thus I would suggest to put this into into the assembler, either at the element matrix level before inserting the matrix into the global matrix or by applying this after the matrix has been assembled.