fix headercheck

dune/gdt/algorithms/newton.hh

@@ -11,6 +11,7 @@
 #define DUNE_GDT_ALGORITHMS_NEWTON_HH
 
 #include <dune/xt/common/parameter.hh>
+#include <dune/xt/common/print.hh>
 #include <dune/xt/common/timedlogging.hh>
 #include <dune/xt/la/container/vector-interface.hh>
 #include <dune/xt/la/solver.hh>

dune/gdt/operators/advection-dg.hh

@@ -76,7 +76,6 @@ protected:
   using D = typename AGV::ctype;
 
 public:
-  using typename BaseType::F;
   using typename BaseType::V;
 
   using I = XT::Grid::extract_intersection_t<AGV>;

dune/gdt/operators/advection-fv.hh

@@ -52,7 +52,6 @@ public:
 
   using BaseType::s_r;
   using BaseType::s_rC;
-  using typename BaseType::F;
   using typename BaseType::V;
 
   using I = XT::Grid::extract_intersection_t<AGV>;

dune/gdt/operators/advection-with-reconstruction.hh

@@ -107,7 +107,7 @@ public:
   {
     this->assert_matching_source(source_vector);
     this->assert_matching_range(range_vector);
-    reconstruction_operator_.apply(source_function, reconstruction_, param);
+    reconstruction_operator_.apply(source_vector, reconstruction_, param);
     range_vector.set_all(0.);
     advection_operator_.apply(reconstruction_.dofs().vector, range_vector);
   }

dune/gdt/operators/reconstruction/linear.hh

@@ -404,7 +404,7 @@ public:
     return source_space_;
   }
 
-  const AssemblyGridViewType& assembly_grid_view() const override final
+  const auto& assembly_grid_view() const override final
   {
     return source_space_.grid_view();
   }

dune/gdt/test/inviscid-compressible-flow/base.hh

@@ -168,9 +168,9 @@ protected:
         });
     if (boundary_treatment.empty()) { // The periodic case
       if (self.space_type_ == "fv")
-        return std::make_unique<AdvectionFvOperator<M, GV, m>>(space.grid_view(), numerical_flux, space, space);
+        return std::make_unique<AdvectionFvOperator<GV, m>>(space.grid_view(), numerical_flux, space, space);
       else
-        return std::make_unique<AdvectionDgOperator<M, GV, m>>(
+        return std::make_unique<AdvectionDgOperator<GV, m>>(
             space.grid_view(),
             numerical_flux,
             space,
@@ -192,12 +192,12 @@ protected:
       boundary_info->register_new_normal({1}, new XT::Grid::ImpermeableBoundary());
       const XT::Grid::ApplyOn::CustomBoundaryIntersections<GV> impermeable_wall_filter(
           *boundary_info, new XT::Grid::ImpermeableBoundary());
-      auto op = std::make_unique<AdvectionFvOperator<M, GV, m>>(space.grid_view(),
-                                                                numerical_flux,
-                                                                space,
-                                                                space,
-                                                                /*use_tbb=*/false,
-                                                                /*periodicity_restriction=*/impermeable_wall_filter);
+      auto op = std::make_unique<AdvectionFvOperator<GV, m>>(space.grid_view(),
+                                                             numerical_flux,
+                                                             space,
+                                                             space,
+                                                             /*use_tbb=*/false,
+                                                             /*periodicity_restriction=*/impermeable_wall_filter);
       // the actual handling of impermeable walls
       op->append(/*numerical_boundary_flux=*/
                  [&](const auto& intersection, const auto& x, const auto& u, auto& ret, const auto& /*param*/) {
@@ -213,12 +213,12 @@ protected:
       boundary_info->register_new_normal({1}, new XT::Grid::ImpermeableBoundary());
       const XT::Grid::ApplyOn::CustomBoundaryIntersections<GV> impermeable_wall_filter(
           *boundary_info, new XT::Grid::ImpermeableBoundary());
-      auto op = std::make_unique<AdvectionFvOperator<M, GV, m>>(space.grid_view(),
-                                                                numerical_flux,
-                                                                space,
-                                                                space,
-                                                                /*use_tbb=*/false,
-                                                                /*periodicity_restriction=*/impermeable_wall_filter);
+      auto op = std::make_unique<AdvectionFvOperator<GV, m>>(space.grid_view(),
+                                                             numerical_flux,
+                                                             space,
+                                                             space,
+                                                             /*use_tbb=*/false,
+                                                             /*periodicity_restriction=*/impermeable_wall_filter);
       // the actual handling of impermeable walls, see [DF2015, p. 415, (8.66 - 8.67)]
       op->append(
           /*boundary_extrapolation=*/
@@ -261,7 +261,7 @@ protected:
           *boundary_info, new XT::Grid::ImpermeableBoundary());
       const XT::Grid::ApplyOn::CustomBoundaryIntersections<GV> inflow_outflow_filter(
           *boundary_info, new XT::Grid::InflowOutflowBoundary());
-      auto op = std::make_unique<AdvectionFvOperator<M, GV, m>>(
+      auto op = std::make_unique<AdvectionFvOperator<GV, m>>(
           space.grid_view(),
           numerical_flux,
           space,

dune/gdt/test/operators/oswald-interpolation.hh

@@ -36,7 +36,6 @@
 #include <dune/gdt/local/integrands/abs.hh>
 #include <dune/gdt/local/integrands/laplace.hh>
 #include <dune/gdt/local/integrands/product.hh>
-#include <dune/gdt/operators/localizable-operator.hh>
 #include <dune/gdt/operators/oswald-interpolation.hh>
 #include <dune/gdt/spaces/l2/finite-volume.hh>
 #include <dune/gdt/spaces/l2/discontinuous-lagrange.hh>
@@ -105,7 +104,7 @@ struct OswaldInterpolationOperatorOnLeafViewTest : public ::testing::Test
   void fulfills_l2_interpolation_estimate()
   {
     auto& self = *this;
-    OswaldInterpolationOperator<M, GV> oswald_interpolation(
+    OswaldInterpolationOperator<GV> oswald_interpolation(
         self.grid_provider->leaf_view(), *self.space, *self.space, *self.boundary_info);
     oswald_interpolation.assemble();
     auto range = make_discrete_function<V>(*self.space);
@@ -227,7 +226,7 @@ struct OswaldInterpolationOperatorOnLeafViewTest : public ::testing::Test
   void fulfills_h1_interpolation_estimate()
   {
     auto& self = *this;
-    OswaldInterpolationOperator<M, GV> oswald_interpolation(
+    OswaldInterpolationOperator<GV> oswald_interpolation(
         self.grid_provider->leaf_view(), *self.space, *self.space, *self.boundary_info);
     oswald_interpolation.assemble();
     auto range = make_discrete_function<V>(*self.space);
@@ -403,7 +402,7 @@ struct OswaldInterpolationOperatorOnCubicLeafViewTest : public OswaldInterpolati
   void applies_correctly_on_cubic_grids()
   {
     auto& self = *this;
-    OswaldInterpolationOperator<M, GV> oswald_interpolation(
+    OswaldInterpolationOperator<GV> oswald_interpolation(
         self.grid_provider->leaf_view(), *self.space, *self.space, *self.boundary_info);
     oswald_interpolation.assemble();
     auto range = make_discrete_function<V>(*self.space);

dune/gdt/test/stokes/stokes-taylorhood.hh

@@ -217,8 +217,8 @@ public:
     auto pattern_C = make_element_sparsity_pattern(pressure_space, pressure_space, grid_view);
     Matrix A(m, m, pattern_A);
     Matrix B(m, n, pattern_B);
-    MatrixOperator<Matrix, GV, d> A_operator(grid_view, velocity_space, velocity_space, A);
-    MatrixOperator<Matrix, GV, 1, 1, d> B_operator(grid_view, pressure_space, velocity_space, B);
+    MatrixOperator<GV, d> A_operator(grid_view, velocity_space, velocity_space, A);
+    MatrixOperator<GV, 1, 1, d> B_operator(grid_view, pressure_space, velocity_space, B);
     // calculate A_{ij} as \int \nabla v_i \nabla v_j
     A_operator.append(LocalElementIntegralBilinearForm<E, d>(LocalLaplaceIntegrand<E, d>(problem_.diffusion())));
     // calculate B_{ij} as \int -\nabla p_i div(v_j)