TNNMGStep: Allow to hand over a Linearization object

For the brittle-fracture code I want to set gradientAwareTrunction
in BCQFConstrainedLinearization, for which the Linearization object
needs to be constructed before the TNNMGStep object.

As a consequence, TNNMGStep now needs to be able to hand over the
'ignore' field to an already-constructed Linearization.

CHANGELOG.md

 # Master (will become release 2.8)
 
-- ...
+- Previously, the `TNNMGStep` class tacitly created the `Linearization` object.
+  Now, a `Linearization` object can be alternatively given to `TNNMGStep`
+  by means of a new `setLinearization` method.  That way, the options of a
+  linearization class can be set and controlled before using it in `TNNMGStep`.
+
 
 ## Deprecations and removals
 

dune/tnnmg/functionals/bcqfconstrainedlinearization.hh

@@ -112,14 +112,32 @@ public:
   using ConstrainedBitVector = BitVector;
 
 
+  /** \brief Construct linearization for a given functional
+   */
+  BoxConstrainedQuadraticFunctionalConstrainedLinearization(const F& f) :
+    f_(f),
+    truncationTolerance_(1e-10),
+    regularizeDiagonal_(false),
+    gradientAwareTruncation_(false)
+  {}
+
+  /** \brief Construct linearization for a given functional and set of degrees of freedom to ignore
+   */
   BoxConstrainedQuadraticFunctionalConstrainedLinearization(const F& f, const BitVector& ignore) :
     f_(f),
-    ignore_(ignore),
+    ignore_(&ignore),
     truncationTolerance_(1e-10),
     regularizeDiagonal_(false),
     gradientAwareTruncation_(false)
   {}
 
+  /** \brief Specify what degrees of freedom to ignore
+   */
+  void setIgnore(const BitVector& ignore)
+  {
+    ignore_ = &ignore;
+  }
+
   void setTruncationTolerance(double tolerance)
   {
     truncationTolerance_ = tolerance;
@@ -168,7 +186,7 @@ public:
     negativeGradient_ = derivative(f_)(x);
     negativeGradient_ *= -1;
     hessian_ = derivative(derivative(f_))(x);
-    truncationFlags_ = ignore_;
+    truncationFlags_ = *ignore_;
 
     // determine which components to truncate
     if (gradientAwareTruncation_)
@@ -204,7 +222,7 @@ public:
 
 private:
   const F& f_;
-  const BitVector& ignore_;
+  const BitVector* ignore_;
 
   double truncationTolerance_;
   bool regularizeDiagonal_;

dune/tnnmg/functionals/quadraticfunctionalconstrainedlinearization.hh

@@ -32,16 +32,23 @@ public:
 
     QuadraticFunctionalConstrainedLinearization(const F& f, const BitVector& ignore) :
         f_(f),
-        ignore_(ignore),
+        ignore_(&ignore),
         truncationTolerance_(1e-10)
     {}
 
+    /** \brief Specify what degrees of freedom to ignore
+     */
+    void setIgnore(const BitVector& ignore)
+    {
+      ignore_ = &ignore;
+    }
+
     void bind(const Vector& x)
     {
         negativeGradient_ = derivative(f_)(x);
         negativeGradient_ *= -1;
         hessian_ = derivative(derivative(f_))(x);
-        truncationFlags_ = ignore_;
+        truncationFlags_ = *ignore_;
 
         // truncate
         for(std::size_t i=0; i<x.size(); ++i)
@@ -88,7 +95,7 @@ public:
 
 private:
     const F& f_;
-    const BitVector& ignore_;
+    const BitVector* ignore_;
 
     double truncationTolerance_;
 

dune/tnnmg/functionals/sumfunctionalconstrainedlinearization.hh

@@ -34,9 +34,27 @@ public:
   : addends_(std::apply([&](auto&&... fi) {
       return std::make_tuple(Addends(fi, ignore)...);
     }, f.functions())),
-    ignore_(ignore)
+    ignore_(&ignore)
   {}
 
+  /** \brief Constructor from a set of addends
+   *
+   * These addends must all be connected to the same functional.
+   */
+  SumFunctionalConstrainedLinearization(Addends... addends)
+  : addends_(addends...)
+  {}
+
+  /** \brief Specify what degrees of freedom to ignore
+   */
+  void setIgnore(const BitVector& ignore)
+  {
+    ignore_ = &ignore;
+    Hybrid::forEach(addends_, [&](auto&& addend) {
+      addend.setIgnore(ignore);
+    });
+  }
+
   /** \brief Pre-compute derivative information at the configuration x
    */
   void bind(const Vector& x)
@@ -64,7 +82,7 @@ public:
     ////////////////////////////////////////////////////
 
     // Truncate all degrees of freedom explicitly requested in the constructor
-    truncationFlags_ = ignore_;
+    truncationFlags_ = *ignore_;
 
     // Also truncate a degree of freedom if one of the addends wants it truncated
     for (std::size_t i=0; i<truncationFlags_.size(); i++)
@@ -142,7 +160,7 @@ private:
   std::tuple<Addends...> addends_;
 
   // Mark degrees of freedom that should be truncated
-  const BitVector& ignore_;
+  const BitVector* ignore_;
 
   Vector negativeGradient_;
   Matrix hessian_;

dune/tnnmg/iterationsteps/tnnmgstep.hh

@@ -118,6 +118,11 @@ public:
     preSmoothingSteps_ = i;
   }
 
+  void setLinearization(std::shared_ptr<Linearization> linearization)
+  {
+    linearization_ = linearization;
+  }
+
   /**
    * \brief Do one TNNMG step
    */
@@ -134,7 +139,9 @@ public:
 
     // Compute constraint/truncated linearization
     if (not linearization_)
+      // TODO: Don't hand over the 'ignore' field.  Requires new constructors for all linearizations!
       linearization_ = std::make_shared<Linearization>(f, ignore);
+    linearization_->setIgnore(ignore);
 
     linearization_->bind(x);
 

examples/trescafriction.cc

@@ -118,10 +118,17 @@ public:
 
     TrescaFrictionFunctionalConstrainedLinearization(const F& f, const BitVector& ignore) :
         f_(f),
-        ignore_(ignore),
+        ignore_(&ignore),
         truncationTolerance_(1e-10)
     {}
 
+    /** \brief Specify what degrees of freedom to ignore
+     */
+    void setIgnore(const BitVector& ignore)
+    {
+      ignore_ = &ignore;
+    }
+
     void bind(const Vector& x)
     {
     constexpr double tolerance = 1e-15;
@@ -180,7 +187,7 @@ public:
     const auto& obstacleFunctional = std::get<0>(f_.functions());
 
     // The ignore_ field contains the Dirichlet dofs
-    truncationFlags_ = ignore_;
+    truncationFlags_ = *ignore_;
 
     // determine which components to truncate
     for (std::size_t i=0; i<x.size(); ++i)
@@ -251,7 +258,7 @@ public:
 
 private:
     const F& f_;
-    const BitVector& ignore_;
+    const BitVector* ignore_;
 
     double truncationTolerance_;