Make trescafrictionfunctionaltest build

dune/tnnmg/functionals/trescafrictionfunctional.hh

@@ -271,7 +271,7 @@ public:
     {
       auto p = (*origin_)[row];
       p.axpy(v, (*direction_)[row]);
-      result += (*coefficients_)[row] * tangentialPart(p).two_norm();
+      result += (*coefficients_)[row][0] * tangentialPart(p).two_norm();
     }
 
     return result;

dune/tnnmg/test/trescafrictionfunctionaltest.cc

@@ -80,11 +80,10 @@ void testCoordinateRestrictionSubdifferential(const Functional& functional,
         for (auto v : testParameters)
         {
           // Test the subdifferential of the restriction
-          Solvers::Interval<double> subDifferential;
-          restriction.subDiff(v, subDifferential);
+          Solvers::Interval<double> subDifferential = restriction.subDifferential(v);
 
           // Step size. Best value: square root of the machine precision
-          constexpr double eps = std::sqrt(std::numeric_limits<double>::epsilon());
+          const double eps = std::sqrt(std::numeric_limits<double>::epsilon());
 
           auto forwardFDGradient  = (restriction(v+eps) - restriction(v)) / eps;
           auto backwardFDGradient = (restriction(v) - restriction(v-eps)) / eps;
@@ -112,36 +111,14 @@ int main(int argc, char* argv[]) try
   // Create a Tresca friction functional on a grid with three vertices for testing
   using M = Matrix<FieldMatrix<double,2,2> >;
   using Vector = BlockVector<FieldVector<double,2> >;
-  // TODO: You would really want something like std::vector<double> for the weights W,
-  // But that would mean different levels of nestedness for the different containers,
-  // and it is not clear to me how coordinate restrictions would work in this situation.
-  using W = BlockVector<FieldVector<double,1> >;
-  //using W = std::vector<double>;
 
-  M matrix(3,3);
-  matrix[0][0] = ScaledIdentityMatrix<double,2>(1);
-  matrix[0][1] = 0;
-  matrix[0][2] = 0;
+  // TODO: TrescaFrictionFunctional currently uses the coefficient vector type
+  // for the weights, too.  That's of course inappropriate, because there is
+  // really only a scalar weight per Lagrange point.
+  // Let's hack around that by simply having the same number twice for each Lagrange point.
+  Vector weights = {{2.0, 2.0}, {3.0, 3.0}, {4.0, 4.0}};
 
-  matrix[1][0] = 0;
-  matrix[1][1] = ScaledIdentityMatrix<double,2>(2);
-  matrix[1][2] = ScaledIdentityMatrix<double,2>(-1);
-
-  matrix[2][0] = 0;
-  matrix[2][1] = ScaledIdentityMatrix<double,2>(-1);
-  matrix[2][2] = ScaledIdentityMatrix<double,2>(1);
-
-  Vector linearPart = {{1,2},{3,4}, {5,6}};
-  Vector lower      = {{-1000000,-1000000},{-1000000,-1000000}, {-1000000,-1000000}};
-  Vector upper      = {{1000000,1000000},{1000000,1000000}, {1000000,1000000}};
-
-  W weights = {2.0, 3.0, 4.0};
-
-  TrescaFrictionFunctional<M, Vector, Vector, Vector, W> functional(matrix,
-                                      linearPart,
-                                      lower,
-                                      upper,
-                                      weights);
+  TrescaFrictionFunctional<Vector> functional(weights);
 
   // A set of local test points, i.e., values for a single vector block
   std::vector<Vector::value_type> localTestPoints = {{0,0},
@@ -183,7 +160,7 @@ int main(int argc, char* argv[]) try
   testCoordinateRestrictionSubdifferential(functional, testPoints, {-3, -2, -1, 0, 1, 2, 3});
 
   return 0;
-} catch (Exception e)
+} catch (Exception& e)
 {
   std::cout << e.what() << std::endl;
 }